From 4ea0fbe113f4fdcbcafbc057ae71febfceb40703 Mon Sep 17 00:00:00 2001
From: guybedford <guybedford@gmail.com>
Date: Thu, 18 Aug 2016 18:06:26 +0200
Subject: [PATCH] move default resolution logic into normalize, document
 symbols

---
 README.md                               | 10 +++++----
 core/loader-polyfill.js                 |  1 +
 core/register-loader.js                 | 27 ++++++++++++++++---------
 test/fixtures/system-register-loader.js |  5 +++--
 4 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index e8bbd0b..9aac63b 100644
--- a/README.md
+++ b/README.md
@@ -57,14 +57,16 @@ class MyCustomLoader extends RegisterLoader {
   /*
    * Default normalize hook
    */
-  normalize(key, parentKey, metadata) {
+  [RegisterLoader.normalize](key, parentKey, metadata) {
+    // parent normalize is sync, providing relative normalization only
+    var relativeResolved = super[RegisterLoader.normalize](key, parentKey, metadata) || key;
     return key;
   }
 
   /*
    * Default instantiate hook
    */
-  instantiate(key, metadata) {
+  [RegisterLoader.instantiate](key, metadata) {
     return undefined;
   }
 }
@@ -92,7 +94,7 @@ When instantiate returns `undefined`, it is assumed that the module key has alre
 For example:
 
 ```javascript
-  instantate(key, metadata) {
+  [RegisterLoader.instantate](key, metadata) {
     this.register(key, deps, declare);
     return undefined;
   }
@@ -102,7 +104,7 @@ When using the anonymous form of System.register - `loader.register(deps, declar
 the context in which it was called, it is necessary to call the `loader.processRegisterContext(contextKey)` method:
 
 ```javascript
-  instantiate(key, metadata) {
+  [RegisterLoader.instantiate](key, metadata) {
     this.register(deps, declare);
     this.processRegisterContext(key);
     return undefined;
diff --git a/core/loader-polyfill.js b/core/loader-polyfill.js
index 29b0704..8389894 100644
--- a/core/loader-polyfill.js
+++ b/core/loader-polyfill.js
@@ -51,6 +51,7 @@ function Loader(baseKey) {
   this.key = baseKey || baseURI;
   this.registry = new Registry();
 
+  // NB deprecate
   // evaluation flag to allow for tracing loaders
   this.execute = true;
 }
diff --git a/core/register-loader.js b/core/register-loader.js
index f4ddef3..d83fdff 100644
--- a/core/register-loader.js
+++ b/core/register-loader.js
@@ -43,9 +43,11 @@ RegisterLoader.prototype.constructor = RegisterLoader;
 // aren't exposed to end-users
 RegisterLoader.normalize = 'normalize';
 RegisterLoader.instantiate = 'instantiate';
+RegisterLoader.createMetadata = 'createMetadata';
 
+// default normalize is the WhatWG style normalizer
 RegisterLoader.prototype.normalize = function(key, parentKey, metadata) {
-  return key;
+  return resolveUrlToParentIfNotPlain(key, parentKey);
 };
 
 RegisterLoader.prototype.instantiate = function(key, metadata) {};
@@ -63,18 +65,25 @@ var RESOLVE = Loader.resolve;
 RegisterLoader.prototype[RESOLVE] = function(key, parentKey) {
   var loader = this;
 
-  var resolved = resolveUrlToParentIfNotPlain(key, parentKey);
-
   // normalization shortpath if already in the registry or loading
-  if (resolved && (loader.registry.has(resolved) || loader._registerRegistry[resolved]))
-    return Promise.resolve(resolved);
+  if (key && (loader.registry.has(key) || loader._registerRegistry[key]))
+    return Promise.resolve(key);
 
   var metadata = this.createMetadata();
-  return Promise.resolve(loader.normalize(resolved || key, parentKey, metadata))
+  return Promise.resolve(loader.normalize(key, parentKey, metadata))
   .then(function(resolvedKey) {
+    if (typeof resolvedKey !== 'string') {
+      if (resolvedKey === undefined)
+        throw new RangeError('No resolution normalizing "' + key + '" to ' + parentKey);
+
+      // allow a non-string resolve for use cases like conditionals
+      return resolvedKey;
+    }
+    
     // we create the in-progress load record already here to store the normalization metadata
     if (!loader.registry.has(resolvedKey))
-      getOrCreateLoadRecord(loader, resolvedKey).metadata = metadata;
+      getOrCreateLoadRecord(loader, resolvedKey, metadata);
+
     return resolvedKey;
   });
 };
@@ -84,10 +93,10 @@ RegisterLoader.prototype[RESOLVE] = function(key, parentKey) {
 // this record represents that waiting period, and when set, we then populate
 // the esLinkRecord record into this load record.
 // instantiate is a promise for a module namespace or undefined
-function getOrCreateLoadRecord(loader, key) {
+function getOrCreateLoadRecord(loader, key, metadata) {
   return loader._registerRegistry[key] || (loader._registerRegistry[key] = {
     key: key,
-    metadata: undefined,
+    metadata: metadata,
 
     instantiatePromise: undefined,
 
diff --git a/test/fixtures/system-register-loader.js b/test/fixtures/system-register-loader.js
index dbed5e5..9b34d4a 100644
--- a/test/fixtures/system-register-loader.js
+++ b/test/fixtures/system-register-loader.js
@@ -30,9 +30,10 @@ 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)
+  var resolved = RegisterLoader.prototype.normalize.call(this, key, parent, metadata);
+  if (!resolved)
     throw new RangeError('System.register loader does not resolve plain module names, resolving "' + key + '" to ' + parent);
-  return key;
+  return resolved;
 };
 
 var fs;