@lppedd/di-wise-neo 0.8.0 → 0.8.1

package/dist/es/index.mjs

@@ -1,3 +1,30 @@
+/**
+ * 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) {
@@ -10,7 +37,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) {
@@ -288,33 +316,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){
@@ -619,7 +620,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();
@@ -986,10 +987,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);
         });
@@ -1019,6 +1032,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);
         });
@@ -1066,6 +1080,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);
         });
@@ -1075,6 +1090,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);
         });
@@ -1140,7 +1156,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();
         }
@@ -1154,13 +1170,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");