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   function handleError(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   function ready() {
  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 + '>';
  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   function load(source) {
 107     resolve(xhr.responseText);
 108   }
 109   function error() {
 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   script = document.currentScript.src.substr(0, document.currentScript.src.lastIndexOf("/")) + "/" + script;
 141   this._workers = new Array(size);
 142   this._ind = 0;
 143   this._size = size;
 144   this._jobs = 0;
 145   this.onmessage = undefined;
 146   this._stopTimeout = undefined;
 147   for (let i = 0; i < size; i++) {
 148     let wrkr = new Worker(script);
 149     wrkr._count = 0;
 150     wrkr._ind = i;
 151     wrkr.onmessage = this._onmessage.bind(this, wrkr);
 152     wrkr.onerror = this._onerror.bind(this);
 153     this._workers[i] = wrkr;
 154   }
 155
 156   this._checkJobs();
 157 };
 158 WorkerPool.prototype = {
 159   postMessage: function (msg) {
 160     if (this._stopTimeout !== undefined) {
 161       clearTimeout(this._stopTimeout);
 162       this._stopTimeout = undefined;
 163     }
 164     let wrkr = this._workers[this._ind % this._size];
 165     wrkr._count++;
 166     this._jobs++;
 167     wrkr.postMessage(msg);
 168     this._ind++;
 169   },
 170
 171   _onmessage: function (wrkr, evt) {
 172     wrkr._count--;
 173     this._jobs--;
 174     this.onmessage(evt, wrkr);
 175     this._checkJobs();
 176   },
 177
 178   _onerror: function(err) {
 179     try {
 180         var evt = new Event('error');
 181     } catch (_eventError) {
 182         var evt = document.createEvent('Event');
 183         evt.initEvent('error', true, true);
 184     }
 185     evt.message = err.message;
 186     evt.filename = err.filename;
 187     evt.lineno = err.lineno;
 188     evt.colno = err.colno;
 189     evt.error = err.error;
 190     window.dispatchEvent(evt);
 191   },
 192
 193   _checkJobs: function () {
 194     if (this._jobs === 0 && this._stopTimeout === undefined) {
 195       // wait for 2s of inactivity before stopping (that should be enough for local loading)
 196       this._stopTimeout = setTimeout(this._stop.bind(this), 2000);
 197     }
 198   },
 199
 200   _stop: function () {
 201     this._workers.forEach(function(wrkr) {
 202       wrkr.terminate();
 203     });
 204   }
 205 };
 206
 207 var promiseMap = new Map();
 208 var babelWorker = new WorkerPool('babel-worker.js', 3);
 209 babelWorker.onmessage = function (evt) {
 210     var promFuncs = promiseMap.get(evt.data.key);
 211     promFuncs.resolve(evt.data);
 212     promiseMap.delete(evt.data.key);
 213 };
 214
 215 // instantiate just needs to run System.register
 216 // so we fetch the source, convert into the Babel System module format, then evaluate it
 217 BrowserESModuleLoader.prototype[RegisterLoader.instantiate] = function(key, processAnonRegister) {
 218   var loader = this;
 219
 220   // load as ES with Babel converting into System.register
 221   return new Promise(function(resolve, reject) {
 222     // anonymous module
 223     if (anonSources[key]) {
 224       resolve(anonSources[key])
 225       anonSources[key] = undefined;
 226     }
 227     // otherwise we fetch
 228     else {
 229       xhrFetch(key, resolve, reject);
 230     }
 231   })
 232   .then(function(source) {
 233     // check our cache first
 234     const cacheEntryTrans = localStorage.getItem(key+'!transpiled');
 235     if (cacheEntryTrans) {
 236       const cacheEntryRaw = localStorage.getItem(key+'!raw');
 237       // TODO: store a hash instead
 238       if (cacheEntryRaw === source) {
 239         return Promise.resolve({key: key, code: cacheEntryTrans, source: source});
 240       }
 241     }
 242     return new Promise(function (resolve, reject) {
 243       promiseMap.set(key, {resolve: resolve, reject: reject});
 244       babelWorker.postMessage({key: key, source: source});
 245     });
 246   }).then(function (data) {
 247     // evaluate without require, exports and module variables
 248     // we leave module in for now to allow module.require access
 249     if (data.key.slice(-8) !== '#nocache') {
 250       try {
 251         localStorage.setItem(key+'!raw', data.source);
 252         localStorage.setItem(data.key+'!transpiled', data.code);
 253       } catch (e) {
 254         if (window.console) {
 255           window.console.warn('Unable to cache transpiled version of ' + key + ': ' + e);
 256         }
 257       }
 258     }
 259     (0, eval)(data.code + '\n//# sourceURL=' + data.key + '!transpiled');
 260     processAnonRegister();
 261   });
 262 };
 263
 264 // create a default loader instance in the browser
 265 if (isBrowser)
 266   loader = new BrowserESModuleLoader();
 267
 268 export default BrowserESModuleLoader;