loader api tests

Author: guybedford

bench/url-resolution.js bench/1-url-resolution.js

@@ -42,7 +42,7 @@ export var envFetch;
 if (typeof XMLHttpRequest != 'undefined')
   envFetch = xhrFetch;
 else if (typeof module !== 'undefined' && module.require && typeof process !== 'undefined')
-  envFetch = fsFetch;
+  envFetch = nodeFetch;
 else if (typeof self !== 'undefined' && self.fetch)
   envFetch = fetchFetch;
 

core/fetch.js

@@ -84,6 +84,7 @@ Loader.prototype.load = function(key, parent) {
  * Registry has been adjusted to use Namespace objects over ModuleStatus objects
  * as part of simplifying loader API implementation
  */
+var iteratorSupport = typeof Symbol !== 'undefined' && Symbol.iterator;
 function Registry() {
   this._registry = {};
 }
@@ -92,31 +93,35 @@ Registry.prototype.constructor = function() {
   throw new TypeError('Custom registries cannot be created.');
 };
 
-if (typeof Symbol !== 'undefined' && Symbol.iterator) {
+if (iteratorSupport) {
   // 4.4.2
   Registry.prototype[Symbol.iterator] = function() {
-    var self = this;
-    return arrayValues(Object.keys(this).map(function(key) {
-      return [key, self[key]]
-    }));
+    return this.entries()[Symbol.iterator]();
   };
+
   // 4.4.3
-  Registry.prototype.entries = Registry.prototype[Symbol.iterator];
+  Registry.prototype.entries = function() {
+    var registry = this._registry;
+    return arrayValues(Object.keys(registry).map(function(key) {
+      return [key, registry[key]];
+    }));
+  };
 }
+
 // 4.4.4
 Registry.prototype.keys = function() {
-  return arrayValues(Object.keys(this));
+  return arrayValues(Object.keys(this._registry));
 };
 // 4.4.5
 Registry.prototype.values = function() {
-  var self = this;
-  return arrayValues(Object.keys(this).map(function(key) {
-    return self[key];
+  var registry = this._registry;
+  return arrayValues(Object.keys(registry).map(function(key) {
+    return registry[key];
   }));
 };
 // 4.4.6
 Registry.prototype.get = function(key) {
-  return this._registry[key] || undefined;
+  return this._registry[key];
 };
 // 4.4.7
 Registry.prototype.set = function(key, namespace) {

core/loader-polyfill.js

@@ -33,6 +33,7 @@
   ],
   "scripts": {
     "test": "node-esml test/runner.js",
+    "test-inspect": "node --inspect node_modules/.bin/node-esml test/runner.js",
     "bench": "node-esml bench/runner.js"
   }
 }

package.json

@@ -0,0 +1,61 @@
+import assert from 'assert';
+import { Loader, Module, InternalModuleNamespace } from '../core/loader-polyfill.js';
+import { pathToFileUrl } from '../core/common.js';
+
+describe('Loader Polyfill API', function() {
+  var loader = new Loader(pathToFileUrl(process.cwd()));
+
+  it('Should be an instance of itself', function() {
+    assert(loader instanceof Loader);
+  });
+
+  it('Should support the full registry API', function() {
+    assert(loader.registry);
+
+    loader.registry.set('asdf', new InternalModuleNamespace({ asdf: 'asdf' }));
+    assert(loader.registry.has('asdf'));
+    var m = loader.registry.get('asdf');
+    assert(m);
+    assert(m instanceof InternalModuleNamespace);
+    assert.equal(m.asdf, 'asdf');
+
+    for (var k of loader.registry.keys())
+      assert.equal(k, 'asdf');
+
+    for (var v of loader.registry.values())
+      assert.equal(v.asdf, 'asdf');
+
+    for (var v of loader.registry.entries()) {
+      assert.equal(v[0], 'asdf');
+      assert.equal(v[1].asdf, 'asdf');
+    }
+
+    for (var v of loader.registry) {
+      assert.equal(v[0], 'asdf');
+      assert.equal(v[1].asdf, 'asdf');
+    }
+
+    assert.equal(loader.registry.delete('asdf'), true);
+    assert.equal(loader.registry.has('asdf'), false);
+  });
+
+  it('Should support Module construction and execution', function() {
+    var evaluated = false;
+    var mutator;
+    var module = new Module({
+      a: { value: 'asdf' }
+    }, function(_mutator) {
+      mutator = _mutator;
+    }, function() {
+      evaluated = true;
+      mutator.a = 'b';
+    });
+
+    assert.equal(module.a, 'asdf');
+    
+    Module.evaluate(module);
+    assert(evaluated);
+
+    assert.equal(module.a, 'b');
+  });
+});

test-old/browser-script-type-module.js

@@ -0,0 +1,61 @@
+import RegisterLoader from '../../core/register-loader.js';
+import { isBrowser, isNode, global, baseURI } from '../../core/common.js';
+import { resolveUrlToParentIfNotPlain } from '../../core/resolve.js';
+import { scriptLoad, nodeFetch } from '../../core/fetch.js';
+
+/*
+ * Example System Register loader
+ *
+ * Loads modules in the browser and Node as System.register modules
+ * Uses <script> injection in the browser, and fs in Node
+ * If the module does not call System.register, an error will be thrown
+ */
+function SystemRegisterLoader(baseKey) {
+  baseKey = resolveUrlToParentIfNotPlain(baseKey || (isNode ? process.cwd() : '.'), baseURI) || baseKey;
+  RegisterLoader.call(this, baseKey);
+
+  var loader = this;
+  
+  // ensure System.register is available
+  global.System = global.System || {};
+  if (typeof global.System.register == 'function')
+    var prevRegister = global.System.register;
+  global.System.register = function() {
+    loader.register.apply(loader, arguments);
+    if (prevRegister)
+      prevRegister.apply(this, arguments);
+  };
+}
+SystemRegisterLoader.prototype = Object.create(RegisterLoader.prototype);
+
+// normalize is never given a relative name like "./x", that part is already handled
+// so we just need to do plain name detect to throw as in the WhatWG spec
+SystemRegisterLoader.prototype.normalize = function(key, parent, metadata) {
+  if (key.indexOf(':') === -1)
+    throw new RangeError('System.register loader does not resolve plain module names, resolving "' + key + '" to ' + parent);
+  return key;
+};
+
+// instantiate just needs to run System.register
+// so we load the module name as a URL, and expect that to run System.register
+SystemRegisterLoader.prototype.instantiate = function(key, metadata) {
+  var loader = this;
+
+  return new Promise(function(resolve, reject) {
+    if (isNode)
+      nodeFetch(key, undefined, function(source) {
+        eval(source);
+        loader.processRegisterContext(key);
+        resolve();
+      }, reject);
+    else if (isBrowser)
+      scriptLoad(key, function() {
+        loader.processRegisterContext(key);
+        resolve();
+      }, reject);
+    else
+      throw new Error('No fetch system defined for this environment.');
+  });
+};
+
+export default SystemRegisterLoader;

test/url-resolution-tests.js test/1-url-resolution-tests.js

@@ -17,4 +17,4 @@ Promise.all(tests.map((test) => loader.import(path.resolve('test/' + test))))
   setTimeout(function() {
     throw err;
   });
-});
+});