systemjs-builder - npm Package Compare versions

Comparing version 0.0.7 to 0.1.0

bower.json

 {
   "name": "systemjs-builder",
   "main": "index.js",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "authors": [
@@ -6,0 +6,0 @@ "guybedford <[e-mail]>"

compilers/amd.js

@@ -1,47 +0,349 @@
-// converts anonymous AMDs into named AMD for the module
-exports.compile = function(load) {
+var System = require('systemjs');
+var traceur = require('traceur');
 
-  var amdRegEx = /((^\s*|[}{\(\);,\n\?\&])\s*define\s*\(\s*)(("[^"]+"|'[^']+')\s*,\s*)?(\[(\s*("[^"]+"|'[^']+')\s*,)*(\s*("[^"]+"|'[^']+')\s*)?\]|function\s*|{|[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*\))/g;
-  
+var ScopeTransformer = traceur.System.get('traceur@0.0.56/src/codegeneration/ScopeTransformer').ScopeTransformer;
+var parseExpression = traceur.System.get('traceur@0.0.56/src/codegeneration/PlaceholderParser').parseExpression;
 
+var compiler = new traceur.Compiler();
 
-  
-  // TODO convert into System.register dynamic form rather
+var CJSRequireTransformer = require('./cjs').CJSRequireTransformer;
 
+// First of two-pass transform
+// lists number of define statements, the named module it defines (if any), and deps
+// second pass will do rewriting based on this info
+// we set this.isAnon, which is true if there is one named define, or one anonymous define
+// if there are more than one anonymous defines, it is invalid
+function AMDDependenciesTransformer(map) {
+  // optional mapping function
+  this.map = map;
+  this.anonDefine = false;
+  this.defineBundle = false;
+  this.deps = [];
+  return ScopeTransformer.call(this, 'define');
+}
+AMDDependenciesTransformer.prototype = Object.create(ScopeTransformer.prototype);
+AMDDependenciesTransformer.prototype.filterAMDDeps = function(deps) {
+  var newDeps = [];
+  deps.forEach(function(dep) {
+    if (['require', 'exports', 'module'].indexOf(dep) != -1)
+      return;
+    newDeps.push(dep);
+  });
+  return newDeps;
+}
+AMDDependenciesTransformer.prototype.transformCallExpression = function(tree) {
+  if (!tree.operand.identifierToken || tree.operand.identifierToken.value != 'define')
+    return;
 
-  // Turns define(...) into System.register(...)
+  var args = tree.args.args;
+  var name = args[0].type === 'LITERAL_EXPRESSION' && args[0].literalToken.processedValue;
 
-  var match;
+  // anonymous define
+  if (!name) {
+    // already defined anonymously -> throw
+    if (this.anonDefine)
+      throw "Multiple defines for anonymous module";
+    this.anonDefine = true;
+  }
+  // named define
+  else {
+    // if we don't have any other defines, 
+    // then let this be an anonymous define
+    if (!this.anonDefine && !this.defineBundle)
+      this.anonDefine = true;
 
-  var parts = [];
+    // otherwise its a bundle only
+    else {
+      this.anonDefine = false;
+      this.deps = [];
+    }
 
-  var lastName;
+    // the above is just to support single modules of the form:
+    // define('jquery')
+    // still loading anonymously
+    // because it is done widely enough to be useful
 
-  var lastIndex = 0;
+    // note this is now a bundle
+    this.defineBundle = true;
+  }
 
-  while (match = amdRegEx.exec(load.source)) {
-    if (match[3]) {
-      // named -> just rename it
-      // NB need to handle naming the module itself as the last defined
-      // lastName = match[3].split(/["']/)[1];
-      var nameIndex = amdRegEx.lastIndex - match[0].length + match[1].length;
-      parts.push(load.source.substr(lastIndex, nameIndex));
-      parts.push('"' + load.name + '", ');
-      parts.push(load.source.substr(nameIndex + match[3].length, amdRegEx.lastIndex - nameIndex - match[3].length));
-      lastIndex = amdRegEx.lastIndex;      
+  // only continue to extracting dependencies if we're anonymous
+  if (!this.anonDefine)
+    return;
+
+  var depTree;
+
+  if (args[0].type === 'ARRAY_LITERAL_EXPRESSION')
+    depTree = args[0];
+  else if (args[1] && args[1].type == 'ARRAY_LITERAL_EXPRESSION')
+    depTree = args[1];
+
+  if (depTree) {
+    // apply the map to the tree
+    if (this.map)
+      depTree.elements = depTree.elements.map(this.map);
+    this.deps = this.filterAMDDeps(depTree.elements.map(function(dep) {
+      return dep.literalToken.processedValue;
+    }));
+    return;
+  }
+
+  var cjsFactory;
+
+  if (args[0].type == 'FUNCTION_EXPRESSION')
+    cjsFactory = args[0];
+  else if (args[0].type == 'LITERAL_EXPRESSION' && args[1] && args[1].type == 'FUNCTION_EXPRESSION')
+    cjsFactory = args[1];
+
+  if (cjsFactory) {
+    // now we need to do a scope transformer for the require function at this position
+    var fnParameters = cjsFactory.parameterList.parameters;
+    var reqName = fnParameters[0] && fnParameters[0].parameter.binding.identifierToken.value;
+    
+    // now we create a new scope transformer and apply it to this function to find every call of
+    // the function reqName, noting the require
+    var cjsRequires = new CJSRequireTransformer(reqName, this.map);
+    cjsFactory.body = cjsRequires.transformAny(cjsFactory.body);
+    this.deps = this.filterAMDDeps(cjsRequires.requires);
+  }
+}
+
+// AMD System.register transpiler
+// This is the second of the two pass transform
+function AMDDefineRegisterTransformer(load, isAnon, depMap) {
+  this.load = load;
+  this.isAnon = isAnon;
+  this.depMap = depMap;
+  return ScopeTransformer.call(this, 'define');
+}
+AMDDefineRegisterTransformer.prototype = Object.create(ScopeTransformer.prototype);
+AMDDefineRegisterTransformer.prototype.transformCallExpression = function(tree) {
+  if (!tree.operand.identifierToken || tree.operand.identifierToken.value != 'define')
+    return ScopeTransformer.prototype.transformCallExpression.call(this, tree);
+
+  var self = this;
+  var args = tree.args.args;
+
+  // only when "exports" is present as an argument
+  // or dependency, does it become "this" for AMD
+  // otherwise "this" must reference the global
+  var bindToExports = false;
+  /*
+    define(['some', 'deps', 'require'], function(some, deps, require) {
+
+    });
+
+    ->
+
+    System.register(['some', 'deps', 'require'], false, function(__require, __exports, __module) {
+      (function(some, deps, require) {
+
+      })(__require('some'), __require('deps'), __require);
+    });
+
+    define(['dep'], factory)
+
+    ->
+
+    System.register(['dep'], false, function(__require, __exports, __module) {
+      return (factory)(__require('dep'));
+    });
+
+
+    define('jquery', [], factory)
+
+    ->
+
+    System.register([], false, factory);
+
+    IF it is the only define
+
+    otherwise we convert an AMD bundle into a register bundle:
+
+    System.register('jquery', [], false, factory);
+
+    Note that when __module is imported, we decorate it with 'uri' and an empty 'config' function
+  */
+  if (args[0].type === 'ARRAY_LITERAL_EXPRESSION' || args[0].type === 'LITERAL_EXPRESSION') {
+
+    var name = this.load.name;
+    var deps = args[0];
+    var factory = args[1];
+
+    if (args[0].type === 'LITERAL_EXPRESSION') {
+      if (!this.isAnon)
+        name = args[0].literalToken.processedValue;
+      deps = args[1];
+      factory = args[2];
     }
-    else {
-      var nameIndex = amdRegEx.lastIndex - match[0].length + match[1].length;
-      parts.push(load.source.substr(lastIndex, nameIndex));
-      parts.push('"' + load.name + '", ');
-      parts.push(load.source.substr(nameIndex, amdRegEx.lastIndex - nameIndex));
-      lastIndex = amdRegEx.lastIndex;
+
+    if (deps.elements.length != 0) {
+      // filter out the special deps "require", "exports", "module"
+      var requireIndex, exportsIndex, moduleIndex;
+
+      var depNames = deps.elements.map(function(dep) {
+        var depValue = dep.literalToken.processedValue
+        if (self.depMap[depValue])
+          depValue = self.depMap[depValue];
+        return depValue;
+      });
+
+      var depCalls = depNames.map(function(depName) {
+        return "__require('" + depName + "')";
+      });
+
+      requireIndex = depNames.indexOf('require');
+      exportsIndex = depNames.indexOf('exports');
+      moduleIndex = depNames.indexOf('module');
+
+      var exportsIndexD = exportsIndex, moduleIndexD = moduleIndex;
+
+      if (requireIndex != -1) {
+        depCalls.splice(requireIndex, 1, '__require');
+        deps.elements.splice(requireIndex, 1);
+        if (exportsIndex > requireIndex)
+          exportsIndexD--;
+        if (moduleIndex > requireIndex)
+          moduleIndexD--;
+      }
+      if (exportsIndex != -1) {
+        bindToExports = true;
+        depCalls.splice(exportsIndex, 1, '__exports');
+        deps.elements.splice(exportsIndexD, 1);
+        if (moduleIndexD > exportsIndexD)
+          moduleIndexD--;
+      }
+      if (moduleIndex != -1) {
+        depCalls.splice(moduleIndex, 1, '__module');
+        deps.elements.splice(moduleIndexD, 1);
+      }
     }
+
+    if (depCalls)
+      return parseExpression([
+        'System.register("' + name + '",',
+        ', false, function(__require, __exports, __module) {\n  return (',
+        ').call(' + (bindToExports ? '__exports' : 'this') + ', ',
+        ');\n});'
+      ], deps, factory, parseExpression([depCalls.join(', ')]));
+    else
+      return parseExpression([
+        'System.register("' + name + '",',
+        ', false, function(__require, __exports, __module) {\n  return (',
+        ').call(' + (bindToExports ? '__exports' : 'this') + ');\n});'
+      ], deps, factory);
   }
 
-  parts.push(load.source.substr(lastIndex));
+    
 
+  /*
+    define({ })
+
+    ->
+
+    System.register([], false, function() {
+      return { };
+    });
+  */
+  if (args[0].type == 'OBJECT_LITERAL_EXPRESSION') {
+    return parseExpression([
+      'System.register("' + this.load.name + '", [], false, function() {\n  return ',
+      ';\n});'
+    ], args[0]);
+  }
+
+  /*
+    define(function(require, exports, module) {
+      require('some-dep');
+    });
+
+    ->
+
+    System.register(['some-dep'], false, function(require, exports, module) {
+      require('some-dep');
+    });
+
+    Note there is a strange subtlety in RequireJS here.
+
+    If there is one argument, 
+  */
+  if (args[0].type == 'FUNCTION_EXPRESSION') {
+    // system loader already extracted the deps for us
+    var requires = this.load.deps.map(function(dep) {
+      return self.depMap[dep] || dep;
+    });
+
+    var params = args[0].parameterList.parameters;
+    if (params.length > 1)
+      bindToExports = true;
+
+    if (bindToExports)
+      return parseExpression([
+        'System.register("' + this.load.name + '", ' + JSON.stringify(requires) + ', false, function(__require, __exports, __module) {\n'
+      + '(',
+        ').call(__exports, __require, __exports, __module);\n'
+      + '});'
+      ], args[0]);
+    else
+      return parseExpression([
+        'System.register("' + this.load.name + '", ' + JSON.stringify(requires) + ', false, ',
+        ');'
+      ], args[0]);
+  }
+}
+
+// override System instantiate to handle AMD dependencies
+exports.attach = function(loader) {
+  var systemInstantiate = loader.instantiate;
+  loader.instantiate = function(load) {
+    var result = systemInstantiate.call(this, load);
+
+    if (load.metadata.format == 'amd') {
+      // extract AMD dependencies using tree parsing
+      var output = compiler.stringToTree({content: load.source});
+      if (output.errors.length)
+        return Promise.reject(output.errors[0]);
+      load.metadata.parseTree = output;
+      var depTransformer = new AMDDependenciesTransformer();
+      depTransformer.transformAny(output.tree);
+
+      // we store the results as meta
+      load.metadata.isAnon = depTransformer.anonDefine;
+
+      return {
+        deps: depTransformer.deps,
+        execute: function() {}
+      };
+    }
+
+    return result;
+  }
+}
+
+exports.remap = function(source, map) {
+  var output = compiler.stringToTree({content: source, options: options});
+  if (output.errors.length)
+    return Promise.reject(output.errors[0]);
+  var transformer = new AMDDependenciesTransformer(map);
+  output.tree = transformer.transformAny(output.tree);
+  output = compiler.treeToString(output);
+  if (output.errors.length)
+    return Promise.reject(output.errors[0]);
+
+  return Promise.resolve({ source: output.js });
+}
+
+
+// converts anonymous AMDs into named AMD for the module
+exports.compile = function(load, normalize, loader) {
+  var output = load.metadata.parseTree;
+  var transformer = new AMDDefineRegisterTransformer(load, load.metadata.isAnon, normalize ? load.depMap : {});
+  output.tree = transformer.transformAny(output.tree);
+  var output = compiler.treeToString(output);
+  if (output.errors.length)
+    return Promise.reject(output.errors[0]);
+
   return Promise.resolve({
-    source: parts.join('') + '\n'
+    source: output.js
   });
 }

compilers/cjs.js

@@ -0,27 +1,90 @@
+// NB move these CommonJS layers out into a static operation on the CommonJS module rather
+
 var path = require('path');
+var traceur = require('traceur');
+var compiler = new traceur.Compiler();
+var ScopeTransformer = traceur.System.get('traceur@0.0.56/src/codegeneration/ScopeTransformer').ScopeTransformer;
 
-// converts CJS into something that will define itself onto the loader
+function CJSRequireTransformer(requireName, map) {
+  this.requireName = requireName;
+  this.map = map;
+  this.requires = [];
+  return ScopeTransformer.call(this, requireName);
+}
+CJSRequireTransformer.prototype = Object.create(ScopeTransformer.prototype);
+CJSRequireTransformer.prototype.transformCallExpression = function(tree) {
+  if (!tree.operand.identifierToken || tree.operand.identifierToken.value != this.requireName)
+    return ScopeTransformer.prototype.transformCallExpression.call(this, tree);
 
+  // found a require
+  var args = tree.args.args;
+  if (args.length && args[0].type == 'LITERAL_EXPRESSION') {
+    if (this.map)
+      args[0].literalToken.value = '"' + this.map(args[0].literalToken.processedValue) + '"';
+
+    this.requires.push(args[0].literalToken.processedValue);
+
+    return ScopeTransformer.prototype.transformCallExpression.call(this, tree);
+  }
+}
+exports.CJSRequireTransformer = CJSRequireTransformer;
+
 function cjsOutput(name, deps, address, source, baseURL) {
   var filename = path.relative(baseURL, address);
   var dirname = path.dirname(filename);
-
-  return 'System.register("' + name + '", ' + JSON.stringify(deps) + ', true, function(require, exports, __moduleName) {\n'
+  var output = 'System.register("' + name + '", ' + JSON.stringify(deps) + ', true, function(require, exports, module) {\n'
     + '  var global = System.global;\n'
     + '  var __define = global.define;\n'
     + '  global.define = undefined;\n'
-    + '  var module = { exports: exports };\n'
-    + '  var process = System.get("@@nodeProcess")["default"];\n'
-    + '    var __filename = "' + filename + '";\n'
-    + '    var __dirname = "' + dirname + '";\n'
-    + '  ' + source.replace(/\n/g, '\n  ') + '\n'
+    + '  var __filename = "' + filename + '";\n'
+    + '  var __dirname = "' + dirname + '";\n'
+    + '  ' + source.toString().replace(/\n/g, '\n  ') + '\n'
     + '  global.define = __define;\n'
     + '  return module.exports;\n'
     + '});\n'
+  return output;
 }
 
-exports.compile = function(load, loader) {
+exports.compile = function(load, normalize, loader) {
+  var deps = normalize ? load.metadata.deps.map(function(dep) { return load.depMap[dep]; }) : load.metadata.deps;
+
+  return Promise.resolve(load.source)
+  .then(function(source) {
+    if (normalize) {
+      return remap(source, function(dep) {
+        return load.depMap[dep];
+      })
+      .then(function(output) {
+        return output.source;
+      });
+    }
+    return source;
+  })
+  .then(function(source) {
+    //console.log(source);
+    return { source: cjsOutput(load.name, deps, load.address, source, loader.baseURL) };
+  });
+}
+
+function remap(source, map, fileName) {
+  var output = compiler.stringToTree({content: source, options:{filename:fileName}});
+
+  if (output.errors.length)
+    return Promise.reject(output.errors[0]);
+  
+  var transformer = new CJSRequireTransformer('require', map);
+  output.tree = transformer.transformAny(output.tree);
+
+  if (output.errors.length)
+    return Promise.reject(output.errors[0]);
+
+  output = compiler.treeToString(output);
+
+  if (output.errors.length)
+    return Promise.reject(output.errors[0]);
+
   return Promise.resolve({
-    source: cjsOutput(load.name, load.metadata.deps, load.address, load.source, loader.baseURL)
+    source: output.js
   });
 }
+exports.remap = remap;

compilers/global.js

@@ -8,15 +8,95 @@ // Converts globals into a form that will define the module onto the loader
 
+// RATHER than prepare and retrieve, detect the globals written and treat as exports
+// this is a really hard problem though as we need to cater to global IIFE detection
+// init can be inlined
+
+
 function globalOutput(name, deps, exportName, init, source) {
-  return 'System.register("' + name + '", ' + JSON.stringify(deps) + ', false, function(__require, __exports, __moduleName) {\n'
-    + '  System.get("@@global-helpers").prepareGlobal(__moduleName, ' + JSON.stringify(deps) + ');\n'
-    + '  ' + source.replace(/\n/g, '\n    ') + '\n'
+  return 'System.register("' + name + '", ' + JSON.stringify(deps) + ', false, function(__require, __exports, __module) {\n'
+    + '  System.get("@@global-helpers").prepareGlobal(__module.id, ' + JSON.stringify(deps) + ');\n'
+    + '  (function() {'
+    + '  ' + source.replace(/\n/g, '\n      ') + '\n'
     + (exportName ? '  this["' + exportName + '"] = ' + exportName + ';\n' : '')
-    + '  return System.get("@@global-helpers").retrieveGlobal(__moduleName, ' + (exportName ? '"' + exportName + '"' : 'false') + (init ? ', ' + init.toString().replace(/\n/g, '\n      ') : '') + ');\n'
+    + '  }).call(System.global);'
+    + '  return System.get("@@global-helpers").retrieveGlobal(__module.id, ' + (exportName ? '"' + exportName + '"' : 'false') + (init ? ', ' + init.toString().replace(/\n/g, '\n      ') : '') + ');\n'
     + '});\n';
 }
 
-exports.compile = function(load) {
+exports.compile = function(load, normalize) {
+  var deps = normalize ? load.metadata.deps.map(function(dep) { return load.depMap[dep]; }) : load.metadata.deps;
+
+  load.source
+
   return Promise.resolve({
-    source: globalOutput(load.name, load.metadata.deps, load.metadata.exports, load.metadata.init, load.source)
+    source: globalOutput(load.name, deps, load.metadata.exports, load.metadata.init, load.source)
   });
 }
+
+exports.sfx = function(loader) {
+
+  return '(function() {\n'
+  + '  var loader = System;\n'
+  + '  var hasOwnProperty = loader.global.hasOwnProperty;\n'
+  + '  var moduleGlobals = {};\n'
+  + '  var curGlobalObj;\n'
+  + '  var ignoredGlobalProps;\n'
+  + '  if (typeof indexOf == \'undefined\')\n'
+  + '    indexOf = Array.prototype.indexOf;\n'
+  + '  System.set("@@global-helpers", System.newModule({\n'
+  + '    prepareGlobal: function(moduleName, deps) {\n'
+  + '      for (var i = 0; i < deps.length; i++) {\n'
+  + '        var moduleGlobal = moduleGlobals[deps[i]];\n'
+  + '        if (moduleGlobal)\n'
+  + '          for (var m in moduleGlobal)\n'
+  + '            loader.global[m] = moduleGlobal[m];\n'
+  + '      }\n'
+  + '      curGlobalObj = {};\n'
+  + '      ignoredGlobalProps = ["indexedDB", "sessionStorage", "localStorage", "clipboardData", "frames", "webkitStorageInfo"];\n'
+  + '      for (var g in loader.global) {\n'
+  + '        if (indexOf.call(ignoredGlobalProps, g) != -1) { continue; }\n'
+  + '        if (!hasOwnProperty || loader.global.hasOwnProperty(g)) {\n'
+  + '          try {\n'
+  + '            curGlobalObj[g] = loader.global[g];\n'
+  + '          } catch (e) {\n'
+  + '            ignoredGlobalProps.push(g);\n'
+  + '          }\n'
+  + '        }\n'
+  + '      }\n'
+  + '    },\n'
+  + '    retrieveGlobal: function(moduleName, exportName, init) {\n'
+  + '      var singleGlobal;\n'
+  + '      var multipleExports;\n'
+  + '      var exports = {};\n'
+  + '      if (init) {\n'
+  + '        var depModules = [];\n'
+  + '        for (var i = 0; i < deps.length; i++)\n'
+  + '          depModules.push(require(deps[i]));\n'
+  + '        singleGlobal = init.apply(loader.global, depModules);\n'
+  + '      }\n'
+  + '      else if (exportName) {\n'
+  + '        var firstPart = exportName.split(".")[0];\n'
+  + '        singleGlobal = eval.call(loader.global, exportName);\n'
+  + '        exports[firstPart] = loader.global[firstPart];\n'
+  + '      }\n'
+  + '      else {\n'
+  + '        for (var g in loader.global) {\n'
+  + '          if (indexOf.call(ignoredGlobalProps, g) != -1)\n'
+  + '            continue;\n'
+  + '          if ((!hasOwnProperty || loader.global.hasOwnProperty(g)) && g != loader.global && curGlobalObj[g] != loader.global[g]) {\n'
+  + '            exports[g] = loader.global[g];\n'
+  + '            if (singleGlobal) {\n'
+  + '              if (singleGlobal !== loader.global[g])\n'
+  + '                multipleExports = true;\n'
+  + '            }\n'
+  + '            else if (singleGlobal !== false) {\n'
+  + '              singleGlobal = loader.global[g];\n'
+  + '            }\n'
+  + '          }\n'
+  + '        }\n'
+  + '      }\n'
+  + '      moduleGlobals[moduleName] = exports;\n'
+  + '      return multipleExports ? exports : singleGlobal;\n'
+  + '    }\n'
+  + '  }));\n'
+  + '})();\n'
+}

compilers/register.js

@@ -13,2 +13,2 @@ // converts anonymous System.register([] into named System.register('name', [], ...
   });
-}
+}

index.js

 var Promise = require('rsvp').Promise;
 
-var traceur = require('traceur');
 var System = exports.System = require('systemjs');
@@ -9,2 +8,3 @@ var fs = require('fs');
 
+var es6Compiler = require('./compilers/es6');
 var registerCompiler = require('./compilers/register');
@@ -15,2 +15,4 @@ var amdCompiler = require('./compilers/amd');
 
+var path = require('path');
+
 // TODO source maps
@@ -31,5 +33,6 @@ var loader = new Loader(System);
 
+amdCompiler.attach(loader);
+amdCompiler.attach(pluginLoader);
 
 exports.build = function(moduleName, config, outFile) {
-
   return exports.trace(moduleName, config)
@@ -41,45 +44,54 @@ .then(function(trace) {
 
+function compileLoad(load, sfx, compilers) {
+  // note which compilers we used
+  compilers = compilers || {};
+  if (load.metadata.build == false) {
+    return;
+  }
+  else if (load.metadata.format == 'es6') {
+    compilers['es6'] = true;
+    return es6Compiler.compile(load, sfx, loader).then(function(result) {
+      return result.source;
+    });
+  }
+  else if (load.metadata.format == 'register') {
+    compilers['register'] = true;
+    return registerCompiler.compile(load, sfx, loader).then(function(result) {
+      return result.source;
+    });
+  }
+  else if (load.metadata.format == 'amd') {
+    compilers['amd'] = true;
+    return amdCompiler.compile(load, sfx, loader).then(function(result) {
+      return result.source;
+    });
+  }
+  else if (load.metadata.format == 'cjs') {
+    compilers['cjs'] = true;
+    return cjsCompiler.compile(load, sfx, loader).then(function(result) {
+      return result.source;
+    });
+  }
+  else if (load.metadata.format == 'global') {
+    compilers['global'] = true;
+    return globalCompiler.compile(load, sfx, loader).then(function(result) {
+      return result.source;
+    });
+  }
+  else if (load.metadata.format == 'defined') {
+    return '';
+  }
+  else {
+    throw "unknown format " + load.metadata.format;
+  }
+}
+
 exports.buildTree = function(tree, outFile) {
   var concatOutput = ['"format register";\n'];
 
-  var treeNames = [];
+  return Promise.all(Object.keys(tree).map(function(name) {
+    var load = tree[name];
 
-  for (var moduleName in tree)
-    treeNames.push(moduleName);
-
-  return Promise.all(treeNames.map(function(name) {
-    var load = tree[name];
-    if (load.metadata.build == false) {
-      return;
-    }
-    else if (load.metadata.format == 'es6') {
-      var result = traceur.compile(load.source, {
-        moduleName: load.name,
-        modules: 'instantiate'
-      });
-      concatOutput.push(result.js);
-    }
-    else if (load.metadata.format == 'register') {
-      return registerCompiler.compile(load, loader).then(function(result) {
-        concatOutput.push(result.source);
-      });
-    }
-    else if (load.metadata.format == 'amd') {
-      return amdCompiler.compile(load, loader).then(function(result) {
-        concatOutput.push(result.source);
-      });
-    }
-    else if (load.metadata.format == 'cjs') {
-      return cjsCompiler.compile(load, loader).then(function(result) {
-        concatOutput.push(result.source);
-      });
-    }
-    else if (load.metadata.format == 'global') {
-      return globalCompiler.compile(load, loader).then(function(result) {
-        concatOutput.push(result.source);
-      });
-    }
-    else {
-      throw "unknown format " + load.metadata.format;
-    }
+    return Promise.resolve(compileLoad(load))
+    .then(concatOutput.push.bind(concatOutput));
   }))
@@ -91,2 +103,53 @@ .then(function() {
 
+exports.buildSFX = function(moduleName, config, outFile) {
+  var concatOutput = [];
+  var compilers = {};
+  return exports.trace(moduleName, config)
+  .then(function(trace) {
+    var tree = trace.tree;
+    moduleName = trace.moduleName;
+    return Promise.all(Object.keys(tree).map(function(name) {
+      var load = tree[name];
+      return Promise.resolve(compileLoad(load, true, compilers))
+      .then(concatOutput.push.bind(concatOutput));
+    }));
+  })
+  // next add sfx headers for formats at the beginning
+  .then(function() {
+    if (compilers.register && registerCompiler.sfx)
+      return registerCompiler.sfx(loader);
+  })
+  .then(function(result) {
+    concatOutput.unshift(result || '');
+    if (compilers.amd && amdCompiler.sfx)
+      return amdCompiler.sfx(loader);
+  })
+  .then(function(result) {
+    concatOutput.unshift(result || '');
+    if (compilers.cjs && cjsCompiler.sfx)
+      return cjsCompiler.sfx(loader);
+  })
+  .then(function(result) {
+    concatOutput.unshift(result || '');
+    if (compilers.global && globalCompiler.sfx)
+      return globalCompiler.sfx(loader);
+  })
+  // next wrap with the core code
+  .then(function(result) {
+    concatOutput.push(result || '');
+    return asp(fs.readFile)(path.resolve(__dirname, './sfx/sfx-core.js'));
+  })
+  .then(function(sfxcore) {
+    concatOutput.unshift("('" + moduleName + "', function(System) {\n");
+    concatOutput.unshift(sfxcore);
+  })
+  .then(function(result) {
+    concatOutput.push("});");
+  })
+  // finally write
+  .then(function() {
+    return asp(fs.writeFile)(outFile, concatOutput.join('\n'));  
+  });
+}
+
 exports.config = function(config) {
@@ -93,0 +156,0 @@ loader.config(config);

package.json

 {
   "name": "systemjs-builder",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "description": "",
@@ -11,7 +11,7 @@ "main": "index.js",
     "rsvp": "^3.0.6",
-    "systemjs": "0.6.7",
-    "traceur": "0.0.49"
+    "systemjs": "0.8.0",
+    "traceur": "0.0.56"
   },
   "devDependencies": {
-    "es6-module-loader": "0.7.1"
+    "es6-module-loader": "0.8.1"
   },
@@ -18,0 +18,0 @@ "scripts": {

test/excluded.js

 "format register";
 
-System.register("tree/second", ["./third", "./cjs"], function($__0) {
+System.register("tree/third", [], function($__export) {
+  return {
+    setters: [],
+    execute: function() {
+      $__export('some', 'exports');
+    }
+  };
+});
+
+System.register("tree/second", ["tree/third", "tree/cjs"], function($__export) {
   "use strict";
@@ -8,14 +17,5 @@ var __moduleName = "tree/second";
   return {
-    exports: {
-      get q() {
-        return q;
-      },
-      set q(value) {
-        q = value;
-      }
-    },
+    setters: [function(m) {}, function(m) {}],
     execute: function() {
-      ;
-      ;
-      q = 4;
+      q = $__export("q", 4);
     }
@@ -25,19 +25,13 @@ };
 
-System.register("tree/first", ["./second", "./amd"], function($__0) {
+System.register("tree/first", ["tree/second", "tree/amd"], function($__export) {
   "use strict";
   var __moduleName = "tree/first";
-  var p;
+  var dep,
+      p;
   return {
-    exports: {
-      get p() {
-        return p;
-      },
-      set p(value) {
-        p = value;
-      }
-    },
+    setters: [function(m) {
+      dep = m.dep;
+    }, function(m) {}],
     execute: function() {
-      ;
-      ;
-      p = 5;
+      p = $__export("p", 5);
     }
@@ -47,19 +41,8 @@ };
 
-System.register("tree/third", [], function(deps) {
-  return {
-    exports: {
-      some: 'exports'
-    },
-    execute: function() {}
-  };
-});
-
-System.register("tree/cjs", [], true, function(require, exports, __moduleName) {
+System.register("tree/cjs", [], true, function(require, exports, module) {
   var global = System.global;
   var __define = global.define;
   global.define = undefined;
-  var module = { exports: exports };
-  var process = System.get("@@nodeProcess")["default"];
-    var __filename = "tree/cjs.js";
-    var __dirname = "tree";
+  var __filename = "tree/cjs.js";
+  var __dirname = "tree";
   exports.cjs = true;
@@ -66,0 +49,0 @@

test/run-build.js

 var builder = require('../index');
 
+var err = function(e) {
+  setTimeout(function() {
+    throw e;
+  });
+}
+
 console.log('Running a multi-format build...');
@@ -10,7 +16,3 @@ builder.build('tree/first', {
 })
-.catch(function(e) {
-  setTimeout(function() {
-    throw e;
-  });
-});
+.catch(err);
 
@@ -20,3 +22,3 @@ var treeFirst;
   treeFirst = traceTree.tree;
-  console.log(JSON.stringify(traceTree, null, 2));
+  // console.log(JSON.stringify(traceTree, null, 2));
 })
@@ -28,2 +30,3 @@ .then(function() {
 .then(function(traceTree) {
+  depTree = traceTree;
   return builder.buildTree(
@@ -33,6 +36,57 @@ builder.subtractTrees(treeFirst, traceTree.tree), 'excluded.js'
 })
-.catch(function(e) {
-  setTimeout(function() {
-    throw e;
-  });
-});
+
+
+.then(function() {
+  return builder.trace('tree/amd-1').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-1.js');
+  })
+})
+
+.then(function() {
+  return builder.trace('tree/amd-2').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-2.js');
+  })
+})
+
+.then(function() {
+  return builder.trace('tree/amd-3').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-3.js');
+  })
+})
+
+.then(function() {
+  return builder.trace('tree/amd-4').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-4.js');
+  })
+})
+
+.then(function() {
+  return builder.trace('tree/amd-5a').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-5a.js');
+  })
+})
+
+.then(function() {
+  return builder.trace('tree/amd-5b').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-5b.js');
+  })
+})
+
+.then(function() {
+  return builder.trace('tree/amd-6a').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-6a.js');
+  })
+})
+
+.then(function() {
+  return builder.trace('tree/amd-6b').then(function(trace) {
+    return builder.buildTree(builder.subtractTrees(trace.tree, treeFirst), 'amd-6b.js');
+  })
+})
+
+.then(function() {
+  return builder.buildSFX('tree/amd-1', {}, 'sfx.js');
+})
+
+.catch(err);
+

test/tree-build.js

 "format register";
 
-System.register("tree/second", ["./third", "./cjs"], function($__0) {
+
+System.register("tree/third", [], function($__export) {
+  return {
+    setters: [],
+    execute: function() {
+      $__export('some', 'exports');
+    }
+  };
+});
+
+System.register("tree/jquery", [], false, function(__require, __exports, __module) {
+  System.get("@@global-helpers").prepareGlobal(__module.id, []);
+  (function() {  this.jquery = {};
+      
+  }).call(System.global);  return System.get("@@global-helpers").retrieveGlobal(__module.id, false);
+});
+
+System.register("tree/second", ["tree/third", "tree/cjs"], function($__export) {
   "use strict";
@@ -8,14 +25,5 @@ var __moduleName = "tree/second";
   return {
-    exports: {
-      get q() {
-        return q;
-      },
-      set q(value) {
-        q = value;
-      }
-    },
+    setters: [function(m) {}, function(m) {}],
     execute: function() {
-      ;
-      ;
-      q = 4;
+      q = $__export("q", 4);
     }
@@ -25,19 +33,34 @@ };
 
-System.register("tree/first", ["./second", "./amd"], function($__0) {
+System.register("tree/global", ["./jquery"], false, function(__require, __exports, __module) {
+  System.get("@@global-helpers").prepareGlobal(__module.id, ["./jquery"]);
+  (function() {  "deps ./jquery";
+      "exports jquery.test";
+      
+      this.jquery = this.jquery || {};
+      this.jquery.test = 'output';
+      
+  this["jquery.test"] = jquery.test;
+  }).call(System.global);  return System.get("@@global-helpers").retrieveGlobal(__module.id, "jquery.test");
+});
+
+System.register("tree/amd", ['./global', './some!./plugin', './text.txt!./text-plugin'], false, function(__require, __exports, __module) {
+  return (function(a, b, c) {
+    return {
+      is: 'amd',
+      text: c
+    };
+  }).call(this, __require('./global'), __require('./some!./plugin'), __require('./text.txt!./text-plugin'));
+});
+
+System.register("tree/first", ["tree/second", "tree/amd"], function($__export) {
   "use strict";
   var __moduleName = "tree/first";
-  var p;
+  var dep,
+      p;
   return {
-    exports: {
-      get p() {
-        return p;
-      },
-      set p(value) {
-        p = value;
-      }
-    },
+    setters: [function(m) {
+      dep = m.dep;
+    }, function(m) {}],
     execute: function() {
-      ;
-      ;
-      p = 5;
+      p = $__export("p", 5);
     }
@@ -47,19 +70,8 @@ };
 
-System.register("tree/third", [], function(deps) {
-  return {
-    exports: {
-      some: 'exports'
-    },
-    execute: function() {}
-  };
-});
-
-System.register("tree/cjs", [], true, function(require, exports, __moduleName) {
+System.register("tree/cjs", [], true, function(require, exports, module) {
   var global = System.global;
   var __define = global.define;
   global.define = undefined;
-  var module = { exports: exports };
-  var process = System.get("@@nodeProcess")["default"];
-    var __filename = "tree/cjs.js";
-    var __dirname = "tree";
+  var __filename = "tree/cjs.js";
+  var __dirname = "tree";
   exports.cjs = true;
@@ -71,17 +83,8 @@
 
-System.register("tree/jquery", [], false, function(__require, __exports, __moduleName) {
-  System.get("@@global-helpers").prepareGlobal(__moduleName, []);
-  this.jquery = {};
-    
-  return System.get("@@global-helpers").retrieveGlobal(__moduleName, false);
-});
-
-System.register("tree/plugin", [], true, function(require, exports, __moduleName) {
+System.register("tree/plugin", [], true, function(require, exports, module) {
   var global = System.global;
   var __define = global.define;
   global.define = undefined;
-  var module = { exports: exports };
-  var process = System.get("@@nodeProcess")["default"];
-    var __filename = "tree/plugin.js";
-    var __dirname = "tree";
+  var __filename = "tree/plugin.js";
+  var __dirname = "tree";
   exports.build = false;
@@ -93,17 +96,11 @@
 
-System.register("tree/global", ["./jquery"], false, function(__require, __exports, __moduleName) {
-  System.get("@@global-helpers").prepareGlobal(__moduleName, ["./jquery"]);
-  "deps ./jquery";
-    "exports jquery.test";
-    
-    this.jquery = this.jquery || {};
-    this.jquery.test = 'output';
-    
-  this["jquery.test"] = jquery.test;
-  return System.get("@@global-helpers").retrieveGlobal(__moduleName, "jquery.test");
+System.register("tree/text.txt!tree/text-plugin", [], true, function(require, exports, module) {
+  var global = System.global;
+  var __define = global.define;
+  global.define = undefined;
+  var __filename = "tree/text.txt";
+  var __dirname = "tree";
+  module.exports = "This is some text";
+  global.define = __define;
+  return module.exports;
 });
-
-define("tree/amd", ['./global', './some!./plugin'], function() {
-  return { is: 'amd' };
-});
-

test/tree/amd.js

@@ -1,3 +0,3 @@
-define(['./global', './some!./plugin'], function() {
-  return { is: 'amd' };
+define(['./global', './some!./plugin', './text.txt!./text-plugin'], function(a, b, c) {
+  return { is: 'amd', text: c };
 });

test/tree/third.js

@@ -1,8 +0,8 @@
-System.register([], function(deps) {
+System.register([], function($__export) {
   return {
-    exports: {
-      some: 'exports'
-    },
-    execute: function() {}
+    setters: [],
+    execute: function() {
+      $__export('some', 'exports');
+    }
   };
 });

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

72465

increased by239.07%

Number of package files

47

increased by104.35%

Lines of code

1813

increased by286.57%

Worsened metrics

Number of low supply chain risk alerts

3

increased by50%

Number of medium supply chain risk alerts

2

increased byInfinity%

Dependency changes

• + Addedes6-module-loader@0.8.2(transitive)

• + Addedsystemjs@0.8.0(transitive)

• + Addedtraceur@0.0.560.0.58(transitive)

• - Removedes6-module-loader@0.7.2(transitive)

• - Removedsystemjs@0.6.7(transitive)

• - Removedtraceur@0.0.490.0.52(transitive)

• Updatedsystemjs@0.8.0

• Updatedtraceur@0.0.56