-
-
Save anonymous/b0efd6a7fa9104862f7d to your computer and use it in GitHub Desktop.
Sample files; trying to do static bundling with an un-bundled external dependency
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
"format global"; | |
(function(global) { | |
var defined = {}; | |
// indexOf polyfill for IE8 | |
var indexOf = Array.prototype.indexOf || function(item) { | |
for (var i = 0, l = this.length; i < l; i++) | |
if (this[i] === item) | |
return i; | |
return -1; | |
} | |
var getOwnPropertyDescriptor = true; | |
try { | |
Object.getOwnPropertyDescriptor({ a: 0 }, 'a'); | |
} | |
catch(e) { | |
getOwnPropertyDescriptor = false; | |
} | |
var defineProperty; | |
(function () { | |
try { | |
if (!!Object.defineProperty({}, 'a', {})) | |
defineProperty = Object.defineProperty; | |
} | |
catch (e) { | |
defineProperty = function(obj, prop, opt) { | |
try { | |
obj[prop] = opt.value || opt.get.call(obj); | |
} | |
catch(e) {} | |
} | |
} | |
})(); | |
function register(name, deps, declare) { | |
if (arguments.length === 4) | |
return registerDynamic.apply(this, arguments); | |
doRegister(name, { | |
declarative: true, | |
deps: deps, | |
declare: declare | |
}); | |
} | |
function registerDynamic(name, deps, executingRequire, execute) { | |
doRegister(name, { | |
declarative: false, | |
deps: deps, | |
executingRequire: executingRequire, | |
execute: execute | |
}); | |
} | |
function doRegister(name, entry) { | |
entry.name = name; | |
// we never overwrite an existing define | |
if (!(name in defined)) | |
defined[name] = entry; | |
// we have to normalize dependencies | |
// (assume dependencies are normalized for now) | |
// entry.normalizedDeps = entry.deps.map(normalize); | |
entry.normalizedDeps = entry.deps; | |
} | |
function buildGroups(entry, groups) { | |
groups[entry.groupIndex] = groups[entry.groupIndex] || []; | |
if (indexOf.call(groups[entry.groupIndex], entry) != -1) | |
return; | |
groups[entry.groupIndex].push(entry); | |
for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { | |
var depName = entry.normalizedDeps[i]; | |
var depEntry = defined[depName]; | |
// not in the registry means already linked / ES6 | |
if (!depEntry || depEntry.evaluated) | |
continue; | |
// now we know the entry is in our unlinked linkage group | |
var depGroupIndex = entry.groupIndex + (depEntry.declarative != entry.declarative); | |
// the group index of an entry is always the maximum | |
if (depEntry.groupIndex === undefined || depEntry.groupIndex < depGroupIndex) { | |
// if already in a group, remove from the old group | |
if (depEntry.groupIndex !== undefined) { | |
groups[depEntry.groupIndex].splice(indexOf.call(groups[depEntry.groupIndex], depEntry), 1); | |
// if the old group is empty, then we have a mixed depndency cycle | |
if (groups[depEntry.groupIndex].length == 0) | |
throw new TypeError("Mixed dependency cycle detected"); | |
} | |
depEntry.groupIndex = depGroupIndex; | |
} | |
buildGroups(depEntry, groups); | |
} | |
} | |
function link(name) { | |
var startEntry = defined[name]; | |
startEntry.groupIndex = 0; | |
var groups = []; | |
buildGroups(startEntry, groups); | |
var curGroupDeclarative = !!startEntry.declarative == groups.length % 2; | |
for (var i = groups.length - 1; i >= 0; i--) { | |
var group = groups[i]; | |
for (var j = 0; j < group.length; j++) { | |
var entry = group[j]; | |
// link each group | |
if (curGroupDeclarative) | |
linkDeclarativeModule(entry); | |
else | |
linkDynamicModule(entry); | |
} | |
curGroupDeclarative = !curGroupDeclarative; | |
} | |
} | |
// module binding records | |
var moduleRecords = {}; | |
function getOrCreateModuleRecord(name) { | |
return moduleRecords[name] || (moduleRecords[name] = { | |
name: name, | |
dependencies: [], | |
exports: {}, // start from an empty module and extend | |
importers: [] | |
}) | |
} | |
function linkDeclarativeModule(entry) { | |
// only link if already not already started linking (stops at circular) | |
if (entry.module) | |
return; | |
var module = entry.module = getOrCreateModuleRecord(entry.name); | |
var exports = entry.module.exports; | |
var declaration = entry.declare.call(global, function(name, value) { | |
module.locked = true; | |
if (typeof name == 'object') { | |
for (var p in name) | |
exports[p] = name[p]; | |
} | |
else { | |
exports[name] = value; | |
} | |
for (var i = 0, l = module.importers.length; i < l; i++) { | |
var importerModule = module.importers[i]; | |
if (!importerModule.locked) { | |
for (var j = 0; j < importerModule.dependencies.length; ++j) { | |
if (importerModule.dependencies[j] === module) { | |
importerModule.setters[j](exports); | |
} | |
} | |
} | |
} | |
module.locked = false; | |
return value; | |
}); | |
module.setters = declaration.setters; | |
module.execute = declaration.execute; | |
// now link all the module dependencies | |
for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { | |
var depName = entry.normalizedDeps[i]; | |
var depEntry = defined[depName]; | |
var depModule = moduleRecords[depName]; | |
// work out how to set depExports based on scenarios... | |
var depExports; | |
if (depModule) { | |
depExports = depModule.exports; | |
} | |
else if (depEntry && !depEntry.declarative) { | |
depExports = depEntry.esModule; | |
} | |
// in the module registry | |
else if (!depEntry) { | |
depExports = load(depName); | |
} | |
// we have an entry -> link | |
else { | |
linkDeclarativeModule(depEntry); | |
depModule = depEntry.module; | |
depExports = depModule.exports; | |
} | |
// only declarative modules have dynamic bindings | |
if (depModule && depModule.importers) { | |
depModule.importers.push(module); | |
module.dependencies.push(depModule); | |
} | |
else | |
module.dependencies.push(null); | |
// run the setter for this dependency | |
if (module.setters[i]) | |
module.setters[i](depExports); | |
} | |
} | |
// An analog to loader.get covering execution of all three layers (real declarative, simulated declarative, simulated dynamic) | |
function getModule(name) { | |
var exports; | |
var entry = defined[name]; | |
if (!entry) { | |
exports = load(name); | |
if (!exports) | |
throw new Error("Unable to load dependency " + name + "."); | |
} | |
else { | |
if (entry.declarative) | |
ensureEvaluated(name, []); | |
else if (!entry.evaluated) | |
linkDynamicModule(entry); | |
exports = entry.module.exports; | |
} | |
if ((!entry || entry.declarative) && exports && exports.__useDefault) | |
return exports['default']; | |
return exports; | |
} | |
function linkDynamicModule(entry) { | |
if (entry.module) | |
return; | |
var exports = {}; | |
var module = entry.module = { exports: exports, id: entry.name }; | |
// AMD requires execute the tree first | |
if (!entry.executingRequire) { | |
for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { | |
var depName = entry.normalizedDeps[i]; | |
var depEntry = defined[depName]; | |
if (depEntry) | |
linkDynamicModule(depEntry); | |
} | |
} | |
// now execute | |
entry.evaluated = true; | |
var output = entry.execute.call(global, function(name) { | |
for (var i = 0, l = entry.deps.length; i < l; i++) { | |
if (entry.deps[i] != name) | |
continue; | |
return getModule(entry.normalizedDeps[i]); | |
} | |
throw new TypeError('Module ' + name + ' not declared as a dependency.'); | |
}, exports, module); | |
if (output) | |
module.exports = output; | |
// create the esModule object, which allows ES6 named imports of dynamics | |
exports = module.exports; | |
if (exports && exports.__esModule) { | |
entry.esModule = exports; | |
} | |
else { | |
entry.esModule = {}; | |
// don't trigger getters/setters in environments that support them | |
if ((typeof exports == 'object' || typeof exports == 'function') && exports !== global) { | |
if (getOwnPropertyDescriptor) { | |
var d; | |
for (var p in exports) | |
if (d = Object.getOwnPropertyDescriptor(exports, p)) | |
defineProperty(entry.esModule, p, d); | |
} | |
else { | |
var hasOwnProperty = exports && exports.hasOwnProperty; | |
for (var p in exports) { | |
if (!hasOwnProperty || exports.hasOwnProperty(p)) | |
entry.esModule[p] = exports[p]; | |
} | |
} | |
} | |
entry.esModule['default'] = exports; | |
defineProperty(entry.esModule, '__useDefault', { | |
value: true | |
}); | |
} | |
} | |
/* | |
* Given a module, and the list of modules for this current branch, | |
* ensure that each of the dependencies of this module is evaluated | |
* (unless one is a circular dependency already in the list of seen | |
* modules, in which case we execute it) | |
* | |
* Then we evaluate the module itself depth-first left to right | |
* execution to match ES6 modules | |
*/ | |
function ensureEvaluated(moduleName, seen) { | |
var entry = defined[moduleName]; | |
// if already seen, that means it's an already-evaluated non circular dependency | |
if (!entry || entry.evaluated || !entry.declarative) | |
return; | |
// this only applies to declarative modules which late-execute | |
seen.push(moduleName); | |
for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { | |
var depName = entry.normalizedDeps[i]; | |
if (indexOf.call(seen, depName) == -1) { | |
if (!defined[depName]) | |
load(depName); | |
else | |
ensureEvaluated(depName, seen); | |
} | |
} | |
if (entry.evaluated) | |
return; | |
entry.evaluated = true; | |
entry.module.execute.call(global); | |
} | |
// magical execution function | |
var modules = {}; | |
function load(name) { | |
if (modules[name]) | |
return modules[name]; | |
// node core modules | |
if (name.substr(0, 6) == '@node/') | |
return require(name.substr(6)); | |
var entry = defined[name]; | |
// first we check if this module has already been defined in the registry | |
if (!entry) | |
throw "Module " + name + " not present."; | |
// recursively ensure that the module and all its | |
// dependencies are linked (with dependency group handling) | |
link(name); | |
// now handle dependency execution in correct order | |
ensureEvaluated(name, []); | |
// remove from the registry | |
defined[name] = undefined; | |
// exported modules get __esModule defined for interop | |
if (entry.declarative) | |
defineProperty(entry.module.exports, '__esModule', { value: true }); | |
// return the defined module object | |
return modules[name] = entry.declarative ? entry.module.exports : entry.esModule; | |
}; | |
return function(mains, depNames, declare) { | |
return function(formatDetect) { | |
formatDetect(function(deps) { | |
var System = { | |
_nodeRequire: typeof require != 'undefined' && require.resolve && typeof process != 'undefined' && require, | |
register: register, | |
registerDynamic: registerDynamic, | |
get: load, | |
set: function(name, module) { | |
modules[name] = module; | |
}, | |
newModule: function(module) { | |
return module; | |
} | |
}; | |
System.set('@empty', {}); | |
// register external dependencies | |
for (var i = 0; i < depNames.length; i++) (function(depName, dep) { | |
if (dep && dep.__esModule) | |
System.register(depName, [], function(_export) { | |
return { | |
setters: [], | |
execute: function() { | |
for (var p in dep) | |
if (p != '__esModule' && !(typeof p == 'object' && p + '' == 'Module')) | |
_export(p, dep[p]); | |
} | |
}; | |
}); | |
else | |
System.registerDynamic(depName, [], false, function() { | |
return dep; | |
}); | |
})(depNames[i], arguments[i]); | |
// register modules in this bundle | |
declare(System); | |
// load mains | |
var firstLoad = load(mains[0]); | |
if (mains.length > 1) | |
for (var i = 1; i < mains.length; i++) | |
load(mains[i]); | |
if (firstLoad.__useDefault) | |
return firstLoad['default']; | |
else | |
return firstLoad; | |
}); | |
}; | |
}; | |
})(typeof self != 'undefined' ? self : global) | |
/* (['mainModule'], ['external-dep'], function($__System) { | |
System.register(...); | |
}) | |
(function(factory) { | |
if (typeof define && define.amd) | |
define(['external-dep'], factory); | |
// etc UMD / module pattern | |
})*/ | |
(['1', '2'], [], function($__System) { | |
$__System.register('1', ['2'], function (_export) { | |
// Main app file | |
// import {echo} from 'app/modules/b.js'; | |
'use strict'; | |
var jQuery; | |
return { | |
setters: [function (_) { | |
jQuery = _['default']; | |
}], | |
execute: function () { | |
jQuery(document).ready(function () { | |
//echo(console, 456); | |
jQuery('<h1>Domready</h1>').appendTo(document.body); | |
}); | |
} | |
}; | |
}); | |
}) | |
(function(factory) { | |
factory(); | |
}); | |
//# sourceMappingURL=app.build.js.map |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Main app file | |
// import {echo} from 'app/modules/b.js'; | |
import jQuery from 'jquery'; | |
jQuery(document).ready(function () { | |
//echo(console, 456); | |
jQuery('<h1>Domready</h1>').appendTo(document.body); | |
}) | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
const path = require('path'); | |
const Builder = require('systemjs-builder'); | |
var builder = new Builder('src', 'system.config.js'); | |
builder.config({ | |
paths: { | |
jquery: 'http://code.jquery.com/jquery-2.1.4.min.js' | |
}, | |
map: { | |
}, | |
meta: { | |
// Ignore a given file (by not tracing it as part of the build) | |
'resource/to/ignore.js': { | |
build: false | |
}, | |
jquery: { | |
build: false | |
} | |
} | |
}); | |
builder | |
.buildStatic( | |
'app/app.js', | |
'./build/app.build.js', { | |
minify: false, | |
mangle: false, | |
//globalDefs: undefined, | |
//ascii: false, | |
sourceMaps: true, | |
fetch: function (load, fetch) { | |
// Override or pre-process a module before bundling it | |
return fetch(load); | |
} | |
}) | |
.then(function () { | |
console.log('Build complete'); | |
}) | |
.catch(function (err) { | |
console.log('Build error'); | |
console.log(err); | |
}); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
System.config({ | |
baseURL: ".", | |
defaultJSExtensions: true, | |
transpiler: "babel", | |
babelOptions: { | |
"optional": [ | |
"runtime" | |
] | |
}, | |
paths: { | |
"github:*": "./jspm_packages/github/*", | |
"npm:*": "./jspm_packages/npm/*" | |
}, | |
buildCSS: true, | |
separateCSS: false, | |
map: { | |
"babel": "npm:babel-core@5.8.34", | |
"babel-runtime": "npm:babel-runtime@5.8.34", | |
"core-js": "npm:core-js@1.2.6", | |
"github:jspm/nodelibs-assert@0.1.0": { | |
"assert": "npm:assert@1.3.0" | |
}, | |
"github:jspm/nodelibs-path@0.1.0": { | |
"path-browserify": "npm:path-browserify@0.0.0" | |
}, | |
"github:jspm/nodelibs-process@0.1.2": { | |
"process": "npm:process@0.11.2" | |
}, | |
"github:jspm/nodelibs-util@0.1.0": { | |
"util": "npm:util@0.10.3" | |
}, | |
"npm:assert@1.3.0": { | |
"util": "npm:util@0.10.3" | |
}, | |
"npm:babel-runtime@5.8.34": { | |
"process": "github:jspm/nodelibs-process@0.1.2" | |
}, | |
"npm:core-js@1.2.6": { | |
"fs": "github:jspm/nodelibs-fs@0.1.2", | |
"path": "github:jspm/nodelibs-path@0.1.0", | |
"process": "github:jspm/nodelibs-process@0.1.2", | |
"systemjs-json": "github:systemjs/plugin-json@0.1.0" | |
}, | |
"npm:inherits@2.0.1": { | |
"util": "github:jspm/nodelibs-util@0.1.0" | |
}, | |
"npm:path-browserify@0.0.0": { | |
"process": "github:jspm/nodelibs-process@0.1.2" | |
}, | |
"npm:process@0.11.2": { | |
"assert": "github:jspm/nodelibs-assert@0.1.0" | |
}, | |
"npm:util@0.10.3": { | |
"inherits": "npm:inherits@2.0.1", | |
"process": "github:jspm/nodelibs-process@0.1.2" | |
} | |
} | |
}); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment