chore(all): prepare release 1.5.2

aurelia · Nov 20, 2019 · 191d7d6 · 191d7d6
1 parent efa8bad
commit 191d7d6
Show file tree

Hide file tree

Showing 14 changed files with 144 additions and 66 deletions.
diff --git a/bower.json b/bower.json
@@ -1,6 +1,6 @@
 {
   "name": "aurelia-dependency-injection",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "A lightweight, extensible dependency injection container for JavaScript.",
   "keywords": [
     "aurelia",

diff --git a/dist/amd/aurelia-dependency-injection.js b/dist/amd/aurelia-dependency-injection.js
@@ -75,6 +75,14 @@ define('aurelia-dependency-injection', ['exports', 'aurelia-metadata', 'aurelia-
       }
       return true;
   });
+  (function (Strategy) {
+      Strategy[Strategy["instance"] = 0] = "instance";
+      Strategy[Strategy["singleton"] = 1] = "singleton";
+      Strategy[Strategy["transient"] = 2] = "transient";
+      Strategy[Strategy["function"] = 3] = "function";
+      Strategy[Strategy["array"] = 4] = "array";
+      Strategy[Strategy["alias"] = 5] = "alias";
+  })(exports.Strategy || (exports.Strategy = {}));
   function isStrategy(actual, expected, state) {
       return actual === expected;
   }
@@ -84,25 +92,25 @@ define('aurelia-dependency-injection', ['exports', 'aurelia-metadata', 'aurelia-
           this.state = state;
       }
       StrategyResolver.prototype.get = function (container, key) {
-          if (isStrategy(this.strategy, 0, this.state)) {
+          if (isStrategy(this.strategy, exports.Strategy.instance, this.state)) {
               return this.state;
           }
-          if (isStrategy(this.strategy, 1, this.state)) {
+          if (isStrategy(this.strategy, exports.Strategy.singleton, this.state)) {
               var singleton = container.invoke(this.state);
               this.state = singleton;
               this.strategy = 0;
               return singleton;
           }
-          if (isStrategy(this.strategy, 2, this.state)) {
+          if (isStrategy(this.strategy, exports.Strategy.transient, this.state)) {
               return container.invoke(this.state);
           }
-          if (isStrategy(this.strategy, 3, this.state)) {
+          if (isStrategy(this.strategy, exports.Strategy.function, this.state)) {
               return this.state(container, key, this);
           }
-          if (isStrategy(this.strategy, 4, this.state)) {
+          if (isStrategy(this.strategy, exports.Strategy.array, this.state)) {
               return this.state[0].get(container, key);
           }
-          if (isStrategy(this.strategy, 5, this.state)) {
+          if (isStrategy(this.strategy, exports.Strategy.alias, this.state)) {
               return container.get(this.state);
           }
           throw new Error('Invalid strategy: ' + this.strategy);
@@ -200,7 +208,7 @@ define('aurelia-dependency-injection', ['exports', 'aurelia-metadata', 'aurelia-
       Factory.prototype.get = function (container) {
           var fn = this._key;
           var resolver = container.getResolver(fn);
-          if (resolver && resolver.strategy === 3) {
+          if (resolver && resolver.strategy === exports.Strategy.function) {
               fn = resolver.state;
           }
           return function () {

diff --git a/dist/aurelia-dependency-injection.d.ts b/dist/aurelia-dependency-injection.d.ts
@@ -47,7 +47,7 @@ export declare const resolver: {
 export interface Resolver {
 	get(container: Container, key: any): any;
 }
-export declare const enum Strategy {
+export declare enum Strategy {
 	instance = 0,
 	singleton = 1,
 	transient = 2,
@@ -62,9 +62,9 @@ export interface StrategyState<TBase, TImpl extends Impl<TBase> = Impl<TBase>, T
 	[Strategy.singleton]: DependencyCtorOrFunctor<TBase, TImpl, TArgs>;
 	[Strategy.transient]: DependencyCtorOrFunctor<TBase, TImpl, TArgs>;
 	[Strategy.function]: StrategyFunctor<TBase, TImpl, TArgs>;
-	[Strategy.array]: [{
+	[Strategy.array]: ({
 		get: (container: Container, key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>) => TImpl;
-	}, ...TImpl[]];
+	} | TImpl)[];
 	[Strategy.alias]: any;
 }
 export declare class StrategyResolver<TBase, TImpl extends Impl<TBase>, TArgs extends Args<TBase>, TStrategyKey extends keyof StrategyState<TBase, TImpl, TArgs>> {

diff --git a/dist/commonjs/aurelia-dependency-injection.js b/dist/commonjs/aurelia-dependency-injection.js
@@ -80,6 +80,14 @@ var resolver = aureliaMetadata.protocol.create('aurelia:resolver', function (tar
     }
     return true;
 });
+(function (Strategy) {
+    Strategy[Strategy["instance"] = 0] = "instance";
+    Strategy[Strategy["singleton"] = 1] = "singleton";
+    Strategy[Strategy["transient"] = 2] = "transient";
+    Strategy[Strategy["function"] = 3] = "function";
+    Strategy[Strategy["array"] = 4] = "array";
+    Strategy[Strategy["alias"] = 5] = "alias";
+})(exports.Strategy || (exports.Strategy = {}));
 function isStrategy(actual, expected, state) {
     return actual === expected;
 }
@@ -89,25 +97,25 @@ var StrategyResolver = (function () {
         this.state = state;
     }
     StrategyResolver.prototype.get = function (container, key) {
-        if (isStrategy(this.strategy, 0, this.state)) {
+        if (isStrategy(this.strategy, exports.Strategy.instance, this.state)) {
             return this.state;
         }
-        if (isStrategy(this.strategy, 1, this.state)) {
+        if (isStrategy(this.strategy, exports.Strategy.singleton, this.state)) {
             var singleton = container.invoke(this.state);
             this.state = singleton;
             this.strategy = 0;
             return singleton;
         }
-        if (isStrategy(this.strategy, 2, this.state)) {
+        if (isStrategy(this.strategy, exports.Strategy.transient, this.state)) {
             return container.invoke(this.state);
         }
-        if (isStrategy(this.strategy, 3, this.state)) {
+        if (isStrategy(this.strategy, exports.Strategy.function, this.state)) {
             return this.state(container, key, this);
         }
-        if (isStrategy(this.strategy, 4, this.state)) {
+        if (isStrategy(this.strategy, exports.Strategy.array, this.state)) {
             return this.state[0].get(container, key);
         }
-        if (isStrategy(this.strategy, 5, this.state)) {
+        if (isStrategy(this.strategy, exports.Strategy.alias, this.state)) {
             return container.get(this.state);
         }
         throw new Error('Invalid strategy: ' + this.strategy);
@@ -205,7 +213,7 @@ var Factory = (function () {
     Factory.prototype.get = function (container) {
         var fn = this._key;
         var resolver = container.getResolver(fn);
-        if (resolver && resolver.strategy === 3) {
+        if (resolver && resolver.strategy === exports.Strategy.function) {
             fn = resolver.state;
         }
         return function () {

diff --git a/dist/es2015/aurelia-dependency-injection.js b/dist/es2015/aurelia-dependency-injection.js
@@ -73,6 +73,15 @@ const resolver = protocol.create('aurelia:resolver', (target) => {
     }
     return true;
 });
+var Strategy;
+(function (Strategy) {
+    Strategy[Strategy["instance"] = 0] = "instance";
+    Strategy[Strategy["singleton"] = 1] = "singleton";
+    Strategy[Strategy["transient"] = 2] = "transient";
+    Strategy[Strategy["function"] = 3] = "function";
+    Strategy[Strategy["array"] = 4] = "array";
+    Strategy[Strategy["alias"] = 5] = "alias";
+})(Strategy || (Strategy = {}));
 function isStrategy(actual, expected, state) {
     return actual === expected;
 }
@@ -82,25 +91,25 @@ let StrategyResolver = class StrategyResolver {
         this.state = state;
     }
     get(container, key) {
-        if (isStrategy(this.strategy, 0, this.state)) {
+        if (isStrategy(this.strategy, Strategy.instance, this.state)) {
             return this.state;
         }
-        if (isStrategy(this.strategy, 1, this.state)) {
+        if (isStrategy(this.strategy, Strategy.singleton, this.state)) {
             const singleton = container.invoke(this.state);
             this.state = singleton;
             this.strategy = 0;
             return singleton;
         }
-        if (isStrategy(this.strategy, 2, this.state)) {
+        if (isStrategy(this.strategy, Strategy.transient, this.state)) {
             return container.invoke(this.state);
         }
-        if (isStrategy(this.strategy, 3, this.state)) {
+        if (isStrategy(this.strategy, Strategy.function, this.state)) {
             return this.state(container, key, this);
         }
-        if (isStrategy(this.strategy, 4, this.state)) {
+        if (isStrategy(this.strategy, Strategy.array, this.state)) {
             return this.state[0].get(container, key);
         }
-        if (isStrategy(this.strategy, 5, this.state)) {
+        if (isStrategy(this.strategy, Strategy.alias, this.state)) {
             return container.get(this.state);
         }
         throw new Error('Invalid strategy: ' + this.strategy);
@@ -181,7 +190,7 @@ let Factory = Factory_1 = class Factory {
     get(container) {
         let fn = this._key;
         const resolver = container.getResolver(fn);
-        if (resolver && resolver.strategy === 3) {
+        if (resolver && resolver.strategy === Strategy.function) {
             fn = resolver.state;
         }
         return (...rest) => container.invoke(fn, rest);
@@ -586,4 +595,4 @@ class SingletonRegistration {
     }
 }
 
-export { _emptyParameters, InvocationHandler, Container, autoinject, inject, invoker, invokeAsFactory, FactoryInvoker, registration, transient, singleton, TransientRegistration, SingletonRegistration, resolver, StrategyResolver, Lazy, All, Optional, Parent, Factory, NewInstance, getDecoratorDependencies, lazy, all, optional, parent, factory, newInstance };
+export { _emptyParameters, InvocationHandler, Container, autoinject, inject, invoker, invokeAsFactory, FactoryInvoker, registration, transient, singleton, TransientRegistration, SingletonRegistration, resolver, Strategy, StrategyResolver, Lazy, All, Optional, Parent, Factory, NewInstance, getDecoratorDependencies, lazy, all, optional, parent, factory, newInstance };
diff --git a/dist/es2017/aurelia-dependency-injection.js b/dist/es2017/aurelia-dependency-injection.js
@@ -73,6 +73,15 @@ const resolver = protocol.create('aurelia:resolver', (target) => {
     }
     return true;
 });
+var Strategy;
+(function (Strategy) {
+    Strategy[Strategy["instance"] = 0] = "instance";
+    Strategy[Strategy["singleton"] = 1] = "singleton";
+    Strategy[Strategy["transient"] = 2] = "transient";
+    Strategy[Strategy["function"] = 3] = "function";
+    Strategy[Strategy["array"] = 4] = "array";
+    Strategy[Strategy["alias"] = 5] = "alias";
+})(Strategy || (Strategy = {}));
 function isStrategy(actual, expected, state) {
     return actual === expected;
 }
@@ -82,25 +91,25 @@ let StrategyResolver = class StrategyResolver {
         this.state = state;
     }
     get(container, key) {
-        if (isStrategy(this.strategy, 0, this.state)) {
+        if (isStrategy(this.strategy, Strategy.instance, this.state)) {
             return this.state;
         }
-        if (isStrategy(this.strategy, 1, this.state)) {
+        if (isStrategy(this.strategy, Strategy.singleton, this.state)) {
             const singleton = container.invoke(this.state);
             this.state = singleton;
             this.strategy = 0;
             return singleton;
         }
-        if (isStrategy(this.strategy, 2, this.state)) {
+        if (isStrategy(this.strategy, Strategy.transient, this.state)) {
             return container.invoke(this.state);
         }
-        if (isStrategy(this.strategy, 3, this.state)) {
+        if (isStrategy(this.strategy, Strategy.function, this.state)) {
             return this.state(container, key, this);
         }
-        if (isStrategy(this.strategy, 4, this.state)) {
+        if (isStrategy(this.strategy, Strategy.array, this.state)) {
             return this.state[0].get(container, key);
         }
-        if (isStrategy(this.strategy, 5, this.state)) {
+        if (isStrategy(this.strategy, Strategy.alias, this.state)) {
             return container.get(this.state);
         }
         throw new Error('Invalid strategy: ' + this.strategy);
@@ -181,7 +190,7 @@ let Factory = Factory_1 = class Factory {
     get(container) {
         let fn = this._key;
         const resolver = container.getResolver(fn);
-        if (resolver && resolver.strategy === 3) {
+        if (resolver && resolver.strategy === Strategy.function) {
             fn = resolver.state;
         }
         return (...rest) => container.invoke(fn, rest);
@@ -586,4 +595,4 @@ class SingletonRegistration {
     }
 }
 
-export { _emptyParameters, InvocationHandler, Container, autoinject, inject, invoker, invokeAsFactory, FactoryInvoker, registration, transient, singleton, TransientRegistration, SingletonRegistration, resolver, StrategyResolver, Lazy, All, Optional, Parent, Factory, NewInstance, getDecoratorDependencies, lazy, all, optional, parent, factory, newInstance };
+export { _emptyParameters, InvocationHandler, Container, autoinject, inject, invoker, invokeAsFactory, FactoryInvoker, registration, transient, singleton, TransientRegistration, SingletonRegistration, resolver, Strategy, StrategyResolver, Lazy, All, Optional, Parent, Factory, NewInstance, getDecoratorDependencies, lazy, all, optional, parent, factory, newInstance };
diff --git a/dist/native-modules/aurelia-dependency-injection.js b/dist/native-modules/aurelia-dependency-injection.js
@@ -76,6 +76,15 @@ var resolver = protocol.create('aurelia:resolver', function (target) {
     }
     return true;
 });
+var Strategy;
+(function (Strategy) {
+    Strategy[Strategy["instance"] = 0] = "instance";
+    Strategy[Strategy["singleton"] = 1] = "singleton";
+    Strategy[Strategy["transient"] = 2] = "transient";
+    Strategy[Strategy["function"] = 3] = "function";
+    Strategy[Strategy["array"] = 4] = "array";
+    Strategy[Strategy["alias"] = 5] = "alias";
+})(Strategy || (Strategy = {}));
 function isStrategy(actual, expected, state) {
     return actual === expected;
 }
@@ -85,25 +94,25 @@ var StrategyResolver = (function () {
         this.state = state;
     }
     StrategyResolver.prototype.get = function (container, key) {
-        if (isStrategy(this.strategy, 0, this.state)) {
+        if (isStrategy(this.strategy, Strategy.instance, this.state)) {
             return this.state;
         }
-        if (isStrategy(this.strategy, 1, this.state)) {
+        if (isStrategy(this.strategy, Strategy.singleton, this.state)) {
             var singleton = container.invoke(this.state);
             this.state = singleton;
             this.strategy = 0;
             return singleton;
         }
-        if (isStrategy(this.strategy, 2, this.state)) {
+        if (isStrategy(this.strategy, Strategy.transient, this.state)) {
             return container.invoke(this.state);
         }
-        if (isStrategy(this.strategy, 3, this.state)) {
+        if (isStrategy(this.strategy, Strategy.function, this.state)) {
             return this.state(container, key, this);
         }
-        if (isStrategy(this.strategy, 4, this.state)) {
+        if (isStrategy(this.strategy, Strategy.array, this.state)) {
             return this.state[0].get(container, key);
         }
-        if (isStrategy(this.strategy, 5, this.state)) {
+        if (isStrategy(this.strategy, Strategy.alias, this.state)) {
             return container.get(this.state);
         }
         throw new Error('Invalid strategy: ' + this.strategy);
@@ -201,7 +210,7 @@ var Factory = (function () {
     Factory.prototype.get = function (container) {
         var fn = this._key;
         var resolver = container.getResolver(fn);
-        if (resolver && resolver.strategy === 3) {
+        if (resolver && resolver.strategy === Strategy.function) {
             fn = resolver.state;
         }
         return function () {
@@ -642,4 +651,4 @@ var SingletonRegistration = (function () {
     return SingletonRegistration;
 }());
 
-export { _emptyParameters, InvocationHandler, Container, autoinject, inject, invoker, invokeAsFactory, FactoryInvoker, registration, transient, singleton, TransientRegistration, SingletonRegistration, resolver, StrategyResolver, Lazy, All, Optional, Parent, Factory, NewInstance, getDecoratorDependencies, lazy, all, optional, parent, factory, newInstance };
+export { _emptyParameters, InvocationHandler, Container, autoinject, inject, invoker, invokeAsFactory, FactoryInvoker, registration, transient, singleton, TransientRegistration, SingletonRegistration, resolver, Strategy, StrategyResolver, Lazy, All, Optional, Parent, Factory, NewInstance, getDecoratorDependencies, lazy, all, optional, parent, factory, newInstance };
diff --git a/dist/system/aurelia-dependency-injection.js b/dist/system/aurelia-dependency-injection.js
@@ -18,6 +18,7 @@ System.register(['aurelia-metadata', 'aurelia-pal'], function (exports, module)
         registration: registration,
         transient: transient,
         singleton: singleton,
+        Strategy: void 0,
         getDecoratorDependencies: getDecoratorDependencies,
         lazy: lazy,
         all: all,
@@ -102,6 +103,15 @@ System.register(['aurelia-metadata', 'aurelia-pal'], function (exports, module)
           }
           return true;
       }));
+      var Strategy;
+      (function (Strategy) {
+          Strategy[Strategy["instance"] = 0] = "instance";
+          Strategy[Strategy["singleton"] = 1] = "singleton";
+          Strategy[Strategy["transient"] = 2] = "transient";
+          Strategy[Strategy["function"] = 3] = "function";
+          Strategy[Strategy["array"] = 4] = "array";
+          Strategy[Strategy["alias"] = 5] = "alias";
+      })(Strategy || (Strategy = exports('Strategy', {})));
       function isStrategy(actual, expected, state) {
           return actual === expected;
       }
@@ -111,25 +121,25 @@ System.register(['aurelia-metadata', 'aurelia-pal'], function (exports, module)
               this.state = state;
           }
           StrategyResolver.prototype.get = function (container, key) {
-              if (isStrategy(this.strategy, 0, this.state)) {
+              if (isStrategy(this.strategy, Strategy.instance, this.state)) {
                   return this.state;
               }
-              if (isStrategy(this.strategy, 1, this.state)) {
+              if (isStrategy(this.strategy, Strategy.singleton, this.state)) {
                   var singleton = container.invoke(this.state);
                   this.state = singleton;
                   this.strategy = 0;
                   return singleton;
               }
-              if (isStrategy(this.strategy, 2, this.state)) {
+              if (isStrategy(this.strategy, Strategy.transient, this.state)) {
                   return container.invoke(this.state);
               }
-              if (isStrategy(this.strategy, 3, this.state)) {
+              if (isStrategy(this.strategy, Strategy.function, this.state)) {
                   return this.state(container, key, this);
               }
-              if (isStrategy(this.strategy, 4, this.state)) {
+              if (isStrategy(this.strategy, Strategy.array, this.state)) {
                   return this.state[0].get(container, key);
               }
-              if (isStrategy(this.strategy, 5, this.state)) {
+              if (isStrategy(this.strategy, Strategy.alias, this.state)) {
                   return container.get(this.state);
               }
               throw new Error('Invalid strategy: ' + this.strategy);
@@ -227,7 +237,7 @@ System.register(['aurelia-metadata', 'aurelia-pal'], function (exports, module)
           Factory.prototype.get = function (container) {
               var fn = this._key;
               var resolver = container.getResolver(fn);
-              if (resolver && resolver.strategy === 3) {
+              if (resolver && resolver.strategy === Strategy.function) {
                   fn = resolver.state;
               }
               return function () {