@lppedd/di-wise-neo 0.8.0 → 0.9.0

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) {
@@ -9,8 +36,10 @@ function expectNever(value) {
     throw new TypeError(tag(`unexpected value ${String(value)}`));
 }
 // @internal
-function throwUnregisteredError(token) {
-    throw new Error(tag(`unregistered token ${token.name}`));
+function throwUnregisteredError(token, name) {
+    const type = isConstructor(token) ? "class" : "token";
+    const spec = name !== undefined ? `[name=${name}]` : "";
+    throw new Error(tag(`unregistered ${type} ${token.name}${spec}`));
 }
 // @internal
 function throwExistingUnregisteredError(sourceToken, targetTokenOrError) {
@@ -74,6 +103,7 @@ class WeakRefMap {
             }
             this.myMap.delete(key);
         }
+        return undefined;
     }
     set(key, value) {
         invariant(!this.get(key));
@@ -288,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){
@@ -612,29 +615,30 @@ function isDisposable(value) {
             localOptional = optionalOrName;
             localName = name;
         }
-        const registration = this.myTokenRegistry.get(token, localName);
+        let registration = this.myTokenRegistry.get(token, localName);
+        if (!registration && isConstructor(token)) {
+            registration = this.autoRegisterClass(token, localName);
+        }
         if (registration) {
             return this.resolveRegistration(token, registration, localName);
         }
-        if (isConstructor(token)) {
-            return this.instantiateClass(token, localOptional);
-        }
-        return optionalOrName ? undefined : throwUnregisteredError(token);
+        return localOptional ? undefined : throwUnregisteredError(token, localName);
     }
     resolveAll(token, optional) {
         this.checkDisposed();
-        const registrations = this.myTokenRegistry.getAll(token);
+        let registrations = this.myTokenRegistry.getAll(token);
+        if (registrations.length === 0 && isConstructor(token)) {
+            const registration = this.autoRegisterClass(token);
+            if (registration) {
+                registrations = [
+                    registration
+                ];
+            }
+        }
         if (registrations.length > 0) {
             return registrations //
             .map((registration)=>this.resolveRegistration(token, registration)).filter((value)=>value != null);
         }
-        if (isConstructor(token)) {
-            const instance = this.instantiateClass(token, optional);
-            return instance === undefined // = could not resolve, but since it is optional
-             ? [] : [
-                instance
-            ];
-        }
         return optional ? [] : throwUnregisteredError(token);
     }
     dispose() {
@@ -684,37 +688,22 @@ function isDisposable(value) {
             throw e;
         }
     }
-    instantiateClass(Class, optional) {
+    autoRegisterClass(Class, name) {
         const metadata = getMetadata(Class);
-        if (metadata.autoRegister ?? this.myOptions.autoRegister) {
-            // Temporarily set eagerInstantiate to false to avoid resolving the class two times:
-            // one inside register(), and the other just below
+        const autoRegister = metadata.autoRegister ?? this.myOptions.autoRegister;
+        if (autoRegister && (name === undefined || metadata.name === name)) {
+            // Temporarily set eagerInstantiate to false to avoid potentially resolving
+            // the class inside register()
             const eagerInstantiate = metadata.eagerInstantiate;
             metadata.eagerInstantiate = false;
             try {
                 this.register(Class);
-                return this.resolve(Class);
+                return this.myTokenRegistry.get(Class, name ?? metadata.name);
             } finally{
                 metadata.eagerInstantiate = eagerInstantiate;
             }
         }
-        const scope = this.resolveScope(metadata.scope?.value);
-        if (optional && scope === Scope.Container) {
-            // It would not be possible to resolve the class in container scope,
-            // as that would require prior registration.
-            // However, since resolution is marked optional, we simply return undefined.
-            return undefined;
-        }
-        assert(scope !== Scope.Container, `unregistered class ${Class.name} cannot be resolved in container scope`);
-        const registration = {
-            provider: metadata.provider,
-            options: {
-                scope: scope
-            },
-            dependencies: metadata.dependencies
-        };
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.resolveScopedValue(registration, (args)=>new Class(...args));
+        return undefined;
     }
     resolveProviderValue(registration, provider) {
         assert(registration.provider === provider, "internal error: mismatching provider");
@@ -986,10 +975,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 +1020,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 +1068,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 +1078,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 +1144,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 +1158,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");