vendor/browser-es-module-loader/src/browser-es-module-loader.js

   1 import RegisterLoader from 'es-module-loader/core/register-loader.js';
   2 import { InternalModuleNamespace as ModuleNamespace } from 'es-module-loader/core/loader-polyfill.js';
   3
   4 import { baseURI, global, isBrowser } from 'es-module-loader/core/common.js';
   5 import { resolveIfNotPlain } from 'es-module-loader/core/resolve.js';
   6
   7 var loader;
   8
   9 // <script type="module"> support
  10 var anonSources = {};
  11 if (typeof document != 'undefined' && document.getElementsByTagName) {
  12   var handleError = function(err) {
  13     // dispatch an error event so that we can display in errors in browsers
  14     // that don't yet support unhandledrejection
  15     if (window.onunhandledrejection === undefined) {
  16       try {
  17         var evt = new Event('error');
  18       } catch (_eventError) {
  19         var evt = document.createEvent('Event');
  20         evt.initEvent('error', true, true);
  21       }
  22       evt.message = err.message;
  23       if (err.fileName) {
  24         evt.filename = err.fileName;
  25         evt.lineno = err.lineNumber;
  26         evt.colno = err.columnNumber;
  27       } else if (err.sourceURL) {
  28         evt.filename = err.sourceURL;
  29         evt.lineno = err.line;
  30         evt.colno = err.column;
  31       }
  32       evt.error = err;
  33       window.dispatchEvent(evt);
  34     }
  35
  36     // throw so it still shows up in the console
  37     throw err;
  38   }
  39
  40   var ready = function() {
  41     document.removeEventListener('DOMContentLoaded', ready, false );
  42
  43     var anonCnt = 0;
  44
  45     var scripts = document.getElementsByTagName('script');
  46     for (var i = 0; i < scripts.length; i++) {
  47       var script = scripts[i];
  48       if (script.type == 'module' && !script.loaded) {
  49         script.loaded = true;
  50         if (script.src) {
  51           loader.import(script.src).catch(handleError);
  52         }
  53         // anonymous modules supported via a custom naming scheme and registry
  54         else {
  55           var uri = './<anon' + ++anonCnt + '>.js';
  56           if (script.id !== ""){
  57             uri = "./" + script.id;
  58           }
  59
  60           var anonName = resolveIfNotPlain(uri, baseURI);
  61           anonSources[anonName] = script.innerHTML;
  62           loader.import(anonName).catch(handleError);
  63         }
  64       }
  65     }
  66   }
  67
  68   // simple DOM ready
  69   if (document.readyState === 'complete')
  70     setTimeout(ready);
  71   else
  72     document.addEventListener('DOMContentLoaded', ready, false);
  73 }
  74
  75 function BrowserESModuleLoader(baseKey) {
  76   if (baseKey)
  77     this.baseKey = resolveIfNotPlain(baseKey, baseURI) || resolveIfNotPlain('./' + baseKey, baseURI);
  78
  79   RegisterLoader.call(this);
  80
  81   var loader = this;
  82
  83   // ensure System.register is available
  84   global.System = global.System || {};
  85   if (typeof global.System.register == 'function')
  86     var prevRegister = global.System.register;
  87   global.System.register = function() {
  88     loader.register.apply(loader, arguments);
  89     if (prevRegister)
  90       prevRegister.apply(this, arguments);
  91   };
  92 }
  93 BrowserESModuleLoader.prototype = Object.create(RegisterLoader.prototype);
  94
  95 // normalize is never given a relative name like "./x", that part is already handled
  96 BrowserESModuleLoader.prototype[RegisterLoader.resolve] = function(key, parent) {
  97   var resolved = RegisterLoader.prototype[RegisterLoader.resolve].call(this, key, parent || this.baseKey) || key;
  98   if (!resolved)
  99     throw new RangeError('ES module loader does not resolve plain module names, resolving "' + key + '" to ' + parent);
 100
 101   return resolved;
 102 };
 103
 104 function xhrFetch(url, resolve, reject) {
 105   var xhr = new XMLHttpRequest();
 106   var load = function(source) {
 107     resolve(xhr.responseText);
 108   }
 109   var error = function() {
 110     reject(new Error('XHR error' + (xhr.status ? ' (' + xhr.status + (xhr.statusText ? ' ' + xhr.statusText  : '') + ')' : '') + ' loading ' + url));
 111   }
 112
 113   xhr.onreadystatechange = function () {
 114     if (xhr.readyState === 4) {
 115       // in Chrome on file:/// URLs, status is 0
 116       if (xhr.status == 0) {
 117         if (xhr.responseText) {
 118           load();
 119         }
 120         else {
 121           // when responseText is empty, wait for load or error event
 122           // to inform if it is a 404 or empty file
 123           xhr.addEventListener('error', error);
 124           xhr.addEventListener('load', load);
 125         }
 126       }
 127       else if (xhr.status === 200) {
 128         load();
 129       }
 130       else {
 131         error();
 132       }
 133     }
 134   };
 135   xhr.open("GET", url, true);
 136   xhr.send(null);
 137 }
 138
 139 var WorkerPool = function (script, size) {
 140   var current = document.currentScript;
 141   // IE doesn't support currentScript
 142   if (!current) {
 143     // We should be the last loaded script
 144     var scripts = document.getElementsByTagName('script');
 145     current = scripts[scripts.length - 1];
 146   }
 147   script = current.src.substr(0, current.src.lastIndexOf("/")) + "/" + script;
 148   this._workers = new Array(size);
 149   this._ind = 0;
 150   this._size = size;
 151   this._jobs = 0;
 152   this.onmessage = undefined;
 153   this._stopTimeout = undefined;
 154   for (var i = 0; i < size; i++) {
 155     var wrkr = new Worker(script);
 156     wrkr._count = 0;
 157     wrkr._ind = i;
 158     wrkr.onmessage = this._onmessage.bind(this, wrkr);
 159     wrkr.onerror = this._onerror.bind(this);
 160     this._workers[i] = wrkr;
 161   }
 162
 163   this._checkJobs();
 164 };
 165 WorkerPool.prototype = {
 166   postMessage: function (msg) {
 167     if (this._stopTimeout !== undefined) {
 168       clearTimeout(this._stopTimeout);
 169       this._stopTimeout = undefined;
 170     }
 171     var wrkr = this._workers[this._ind % this._size];
 172     wrkr._count++;
 173     this._jobs++;
 174     wrkr.postMessage(msg);
 175     this._ind++;
 176   },
 177
 178   _onmessage: function (wrkr, evt) {
 179     wrkr._count--;
 180     this._jobs--;
 181     this.onmessage(evt, wrkr);
 182     this._checkJobs();
 183   },
 184
 185   _onerror: function(err) {
 186     try {
 187         var evt = new Event('error');
 188     } catch (_eventError) {
 189         var evt = document.createEvent('Event');
 190         evt.initEvent('error', true, true);
 191     }
 192     evt.message = err.message;
 193     evt.filename = err.filename;
 194     evt.lineno = err.lineno;
 195     evt.colno = err.colno;
 196     evt.error = err.error;
 197     window.dispatchEvent(evt);
 198   },
 199
 200   _checkJobs: function () {
 201     if (this._jobs === 0 && this._stopTimeout === undefined) {
 202       // wait for 2s of inactivity before stopping (that should be enough for local loading)
 203       this._stopTimeout = setTimeout(this._stop.bind(this), 2000);
 204     }
 205   },
 206
 207   _stop: function () {
 208     this._workers.forEach(function(wrkr) {
 209       wrkr.terminate();
 210     });
 211   }
 212 };
 213
 214 var promiseMap = new Map();
 215 var babelWorker = new WorkerPool('babel-worker.js', 3);
 216 babelWorker.onmessage = function (evt) {
 217     var promFuncs = promiseMap.get(evt.data.key);
 218     promFuncs.resolve(evt.data);
 219     promiseMap.delete(evt.data.key);
 220 };
 221
 222 // instantiate just needs to run System.register
 223 // so we fetch the source, convert into the Babel System module format, then evaluate it
 224 BrowserESModuleLoader.prototype[RegisterLoader.instantiate] = function(key, processAnonRegister) {
 225   var loader = this;
 226
 227   // load as ES with Babel converting into System.register
 228   return new Promise(function(resolve, reject) {
 229     // anonymous module
 230     if (anonSources[key]) {
 231       resolve(anonSources[key])
 232       anonSources[key] = undefined;
 233     }
 234     // otherwise we fetch
 235     else {
 236       xhrFetch(key, resolve, reject);
 237     }
 238   })
 239   .then(function(source) {
 240     // check our cache first
 241     var cacheEntry = localStorage.getItem(key);
 242     if (cacheEntry) {
 243       cacheEntry = JSON.parse(cacheEntry);
 244       // TODO: store a hash instead
 245       if (cacheEntry.source === source) {
 246         return Promise.resolve({key: key, code: cacheEntry.code, source: cacheEntry.source});
 247       }
 248     }
 249     return new Promise(function (resolve, reject) {
 250       promiseMap.set(key, {resolve: resolve, reject: reject});
 251       babelWorker.postMessage({key: key, source: source});
 252     });
 253   }).then(function (data) {
 254     // evaluate without require, exports and module variables
 255     // we leave module in for now to allow module.require access
 256     try {
 257       var cacheEntry = JSON.stringify({source: data.source, code: data.code});
 258       localStorage.setItem(key, cacheEntry);
 259     } catch (e) {
 260       if (window.console) {
 261         window.console.warn('Unable to cache transpiled version of ' + key + ': ' + e);
 262       }
 263     }
 264     (0, eval)(data.code + '\n//# sourceURL=' + data.key + '!transpiled');
 265     processAnonRegister();
 266   });
 267 };
 268
 269 // create a default loader instance in the browser
 270 if (isBrowser)
 271   loader = new BrowserESModuleLoader();
 272
 273 export default BrowserESModuleLoader;