@lppedd/di-wise-neo 0.8.0 → 0.8.1

package/dist/cjs/index.js

@@ -1,5 +1,32 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
+/**
+ * Type API.
+ */ /**
+ * Creates a type token.
+ *
+ * @example
+ * ```ts
+ * const ISpell = createType<Spell>("Spell");
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function createType(typeName) {
+    const type = {
+        name: `Type<${typeName}>`,
+        inter: createType,
+        union: createType,
+        toString () {
+            return type.name;
+        }
+    };
+    return type;
+}
+// @internal
+function isConstructor(token) {
+    return typeof token === "function";
+}
+
 // @internal
 function assert(condition, message) {
     if (!condition) {
@@ -12,7 +39,8 @@ function expectNever(value) {
 }
 // @internal
 function throwUnregisteredError(token) {
-    throw new Error(tag(`unregistered token ${token.name}`));
+    const type = isConstructor(token) ? "class" : "token";
+    throw new Error(tag(`unregistered ${type} ${token.name}`));
 }
 // @internal
 function throwExistingUnregisteredError(sourceToken, targetTokenOrError) {
@@ -290,33 +318,6 @@ const Scope = {
     Container: "Container"
 };
 
-/**
- * Type API.
- */ /**
- * Creates a type token.
- *
- * @example
- * ```ts
- * const ISpell = createType<Spell>("Spell");
- * ```
- *
- * @__NO_SIDE_EFFECTS__
- */ function createType(typeName) {
-    const type = {
-        name: `Type<${typeName}>`,
-        inter: createType,
-        union: createType,
-        toString () {
-            return type.name;
-        }
-    };
-    return type;
-}
-// @internal
-function isConstructor(token) {
-    return typeof token === "function";
-}
-
 // @internal
 function getTypeName(value) {
     switch(typeof value){
@@ -621,7 +622,7 @@ function isDisposable(value) {
         if (isConstructor(token)) {
             return this.instantiateClass(token, localOptional);
         }
-        return optionalOrName ? undefined : throwUnregisteredError(token);
+        return localOptional ? undefined : throwUnregisteredError(token);
     }
     resolveAll(token, optional) {
         this.checkDisposed();
@@ -988,10 +989,22 @@ function updateParameterMetadata(decorator, target, propertyKey, parameterIndex,
         updateFn(dependency);
     }
 }
+// Checks that a constructor or method parameter has only one injection decorator.
+// For example, if both `@Inject` and `@Optional` are used, it becomes difficult to
+// understand which one "wins", unless the user is aware of the decorator evaluation order.
+//
+// @internal
+function checkSingleDecorator(dependency, target, propertyKey, parameterIndex) {
+    assert(!dependency.appliedBy, ()=>{
+        const where = propertyKey === undefined ? `${target.name} constructor` : `${target.constructor.name}.${String(propertyKey)}`;
+        return `${where} parameter ${parameterIndex} declares multiple injection decorators, but only one is allowed`;
+    });
+}
 
 function Inject(token) {
     return function(target, propertyKey, parameterIndex) {
         updateParameterMetadata("Inject", target, propertyKey, parameterIndex, (dependency)=>{
+            checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "Inject";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
         });
@@ -1021,6 +1034,7 @@ function Inject(token) {
 function InjectAll(token) {
     return function(target, propertyKey, parameterIndex) {
         updateParameterMetadata("InjectAll", target, propertyKey, parameterIndex, (dependency)=>{
+            checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "InjectAll";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
         });
@@ -1068,6 +1082,7 @@ function InjectAll(token) {
 function Optional(token) {
     return function(target, propertyKey, parameterIndex) {
         updateParameterMetadata("Optional", target, propertyKey, parameterIndex, (dependency)=>{
+            checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "Optional";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
         });
@@ -1077,6 +1092,7 @@ function Optional(token) {
 function OptionalAll(token) {
     return function(target, propertyKey, parameterIndex) {
         updateParameterMetadata("OptionalAll", target, propertyKey, parameterIndex, (dependency)=>{
+            checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "OptionalAll";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
         });
@@ -1142,7 +1158,7 @@ function OptionalAll(token) {
     const resolution = context.resolution;
     const dependentFrame = resolution.stack.peek();
     const dependentRef = dependentFrame && resolution.dependents.get(dependentFrame.provider);
-    function withContext(fn) {
+    const runInContext = (fn)=>{
         if (useInjectionContext()) {
             return fn();
         }
@@ -1156,13 +1172,13 @@ function OptionalAll(token) {
         } finally{
             cleanups.forEach((cleanup)=>cleanup?.());
         }
-    }
+    };
     return {
-        inject: (token, name)=>withContext(()=>inject(token, name)),
-        injectAll: (token)=>withContext(()=>injectAll(token)),
-        optional: (token, name)=>withContext(()=>optional(token, name)),
-        optionalAll: (token)=>withContext(()=>optionalAll(token)),
-        runInContext: withContext
+        inject: (token, name)=>runInContext(()=>inject(token, name)),
+        injectAll: (token)=>runInContext(()=>injectAll(token)),
+        optional: (token, name)=>runInContext(()=>optional(token, name)),
+        optionalAll: (token)=>runInContext(()=>optionalAll(token)),
+        runInContext
     };
 }, "Injector");