@lppedd/di-wise-neo 0.8.1 → 0.9.1

package/dist/cjs/index.js

@@ -28,7 +28,7 @@ function isConstructor(token) {
 }
 
 // @internal
-function assert(condition, message) {
+function check(condition, message) {
     if (!condition) {
         throw new Error(tag(typeof message === "string" ? message : message()));
     }
@@ -38,9 +38,10 @@ function expectNever(value) {
     throw new TypeError(tag(`unexpected value ${String(value)}`));
 }
 // @internal
-function throwUnregisteredError(token) {
+function throwUnregisteredError(token, name) {
     const type = isConstructor(token) ? "class" : "token";
-    throw new Error(tag(`unregistered ${type} ${token.name}`));
+    const spec = name !== undefined ? `[name=${name}]` : "";
+    throw new Error(tag(`unregistered ${type} ${token.name}${spec}`));
 }
 // @internal
 function throwExistingUnregisteredError(sourceToken, targetTokenOrError) {
@@ -59,13 +60,6 @@ function untag(message) {
     return message.startsWith("[di-wise-neo]") ? message.substring(13).trimStart() : message;
 }
 
-// @internal
-function invariant(condition) {
-    if (!condition) {
-        throw new Error("invariant violation");
-    }
-}
-
 // @internal
 class KeyedStack {
     has(key) {
@@ -76,7 +70,7 @@ class KeyedStack {
         return entry?.value;
     }
     push(key, value) {
-        invariant(!this.has(key));
+        check(!this.has(key), "invariant violation");
         this.myKeys.add(key);
         this.myEntries.push({
             key,
@@ -104,9 +98,10 @@ class WeakRefMap {
             }
             this.myMap.delete(key);
         }
+        return undefined;
     }
     set(key, value) {
-        invariant(!this.get(key));
+        check(!this.get(key), "invariant violation");
         this.myMap.set(key, new WeakRef(value));
         return ()=>{
             this.myMap.delete(key);
@@ -130,7 +125,7 @@ const [provideInjectionContext, useInjectionContext] = createInjectionContext();
 // @internal
 function ensureInjectionContext(name) {
     const context = useInjectionContext();
-    assert(context, `${name} can only be invoked within an injection context`);
+    check(context, `${name} can only be invoked within an injection context`);
     return context;
 }
 function createInjectionContext() {
@@ -360,13 +355,13 @@ class TokenRegistry {
         ] || this.getAllFromParent(token, name);
     }
     set(token, registration) {
-        assert(!internals.has(token), `cannot register reserved token ${token.name}`);
+        check(!internals.has(token), `cannot register reserved token ${token.name}`);
         let registrations = this.myMap.get(token);
         if (!registrations) {
             this.myMap.set(token, registrations = []);
         } else if (registration.name !== undefined) {
             const existing = registrations.filter((r)=>r.name === registration.name);
-            assert(existing.length === 0, `a ${token.name} token named '${registration.name}' is already registered`);
+            check(existing.length === 0, `a ${token.name} token named '${registration.name}' is already registered`);
         }
         registrations.push(registration);
     }
@@ -420,7 +415,7 @@ class TokenRegistry {
         let registrations = thisRegistrations || this.myParent?.getAllFromParent(token, name);
         if (registrations && name !== undefined) {
             registrations = registrations.filter((r)=>r.name === name);
-            assert(registrations.length < 2, `internal error: more than one registration named '${name}'`);
+            check(registrations.length < 2, `internal error: more than one registration named '${name}'`);
         }
         return registrations ?? [];
     }
@@ -561,7 +556,7 @@ function isDisposable(value) {
             const [token, provider, options] = args;
             const existingProvider = isExistingProvider(provider);
             const name = existingProvider ? undefined : provider.name;
-            assert(name === undefined || name.trim(), "the provider name qualifier cannot be empty or blank");
+            check(name === undefined || name.trim(), "the provider name qualifier cannot be empty or blank");
             if (isClassProvider(provider)) {
                 const metadata = getMetadata(provider.useClass);
                 const registration = {
@@ -582,7 +577,7 @@ function isDisposable(value) {
                 }
             } else {
                 if (existingProvider) {
-                    assert(token !== provider.useExisting, `the useExisting token ${token.name} cannot be the same as the token being registered`);
+                    check(token !== provider.useExisting, `the useExisting token ${token.name} cannot be the same as the token being registered`);
                 }
                 this.myTokenRegistry.set(token, {
                     name: name,
@@ -615,29 +610,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 localOptional ? 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() {
@@ -687,40 +683,25 @@ 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");
+        check(registration.provider === provider, "internal error: mismatching provider");
         if (isClassProvider(provider)) {
             const Class = provider.useClass;
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
@@ -733,9 +714,7 @@ function isDisposable(value) {
         if (isValueProvider(provider)) {
             return provider.useValue;
         }
-        if (isExistingProvider(provider)) {
-            assert(false, "internal error: unexpected ExistingProvider");
-        }
+        check(!isExistingProvider(provider), "internal error: unexpected ExistingProvider");
         expectNever(provider);
     }
     resolveScopedValue(registration, factory) {
@@ -751,7 +730,7 @@ function isDisposable(value) {
         const options = registration.options;
         if (resolution.stack.has(provider)) {
             const dependentRef = resolution.dependents.get(provider);
-            assert(dependentRef, "circular dependency detected");
+            check(dependentRef, "circular dependency detected");
             return dependentRef.current;
         }
         const scope = this.resolveScope(options?.scope, context);
@@ -810,13 +789,13 @@ function isDisposable(value) {
     resolveConstructorDependencies(registration) {
         const dependencies = registration.dependencies;
         if (dependencies) {
-            assert(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
             const ctorDeps = dependencies.constructor.filter((d)=>d.appliedBy);
             if (ctorDeps.length > 0) {
                 // Let's check if all necessary constructor parameters are decorated.
                 // If not, we cannot safely create an instance.
                 const ctor = registration.provider.useClass;
-                assert(ctor.length === ctorDeps.length, ()=>{
+                check(ctor.length === ctorDeps.length, ()=>{
                     const msg = `expected ${ctor.length} decorated constructor parameters in ${ctor.name}`;
                     return msg + `, but found ${ctorDeps.length}`;
                 });
@@ -840,7 +819,7 @@ function isDisposable(value) {
     injectDependencies(registration, instance) {
         const dependencies = registration.dependencies;
         if (dependencies) {
-            assert(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
             const ctor = registration.provider.useClass;
             // Perform method injection
             for (const entry of dependencies.methods){
@@ -850,7 +829,7 @@ function isDisposable(value) {
                 // If not, we cannot safely invoke the method.
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 const method = instance[key];
-                assert(methodDeps.length === method.length, ()=>{
+                check(methodDeps.length === method.length, ()=>{
                     const msg = `expected ${method.length} decorated method parameters`;
                     return msg + ` in ${ctor.name}.${String(key)}, but found ${methodDeps.length}`;
                 });
@@ -874,7 +853,7 @@ function isDisposable(value) {
         return instance;
     }
     checkDisposed() {
-        assert(!this.myDisposed, "the container is disposed");
+        check(!this.myDisposed, "the container is disposed");
     }
 }
 
@@ -930,7 +909,7 @@ function isDisposable(value) {
     return function(Class) {
         const metadata = getMetadata(Class);
         const currentScope = metadata.scope;
-        assert(!currentScope || currentScope.value === Scope.Container, ()=>{
+        check(!currentScope || currentScope.value === Scope.Container, ()=>{
             const { value, appliedBy } = currentScope;
             return `class ${Class.name}: Scope.${value} was already set by @${appliedBy},\n  ` + `but @EagerInstantiate is trying to set a conflicting Scope.Container.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;
         });
@@ -955,7 +934,7 @@ function forwardRef(token) {
         },
         getRefToken: ()=>{
             const tokenOrTokens = token();
-            assert(!Array.isArray(tokenOrTokens), "internal error: ref tokens should be a single token");
+            check(!Array.isArray(tokenOrTokens), "internal error: ref tokens should be a single token");
             return tokenOrTokens;
         }
     };
@@ -975,7 +954,7 @@ function isTokenRef(value) {
 function updateParameterMetadata(decorator, target, propertyKey, parameterIndex, updateFn) {
     // Error out immediately if the decorator has been applied to a static method
     if (propertyKey !== undefined && typeof target === "function") {
-        assert(false, `@${decorator} cannot be used on static method ${target.name}.${String(propertyKey)}`);
+        check(false, `@${decorator} cannot be used on static method ${target.name}.${String(propertyKey)}`);
     }
     if (propertyKey === undefined) {
         // Constructor
@@ -995,11 +974,30 @@ function updateParameterMetadata(decorator, target, propertyKey, parameterIndex,
 //
 // @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`;
+    check(dependency.appliedBy === undefined, ()=>{
+        const location = getLocation(target, propertyKey, parameterIndex);
+        return `multiple injection decorators on ${location}, but only one is allowed`;
+    });
+}
+// Checks that the `@Named` decorator is not used in combination with
+// `@InjectAll` or `@OptionalAll`, which ignore the name qualification.
+//
+// @internal
+function checkNamedDecorator(dependency, target, propertyKey, parameterIndex) {
+    const { appliedBy, name } = dependency;
+    check(name === undefined || appliedBy !== "InjectAll" && appliedBy !== "OptionalAll", ()=>{
+        const location = getLocation(target, propertyKey, parameterIndex);
+        return `@Named has no effect on ${location} when used with @${appliedBy}`;
     });
 }
+// Returns a human-readable description of the parameter location.
+// For example: "Wizard constructor parameter 2" or "Wizard.set parameter 0"
+//
+// @internal
+function getLocation(target, propertyKey, parameterIndex) {
+    const location = propertyKey === undefined ? `${target.name} constructor` : `${target.constructor.name}.${String(propertyKey)}`;
+    return `${location} parameter ${parameterIndex}`;
+}
 
 function Inject(token) {
     return function(target, propertyKey, parameterIndex) {
@@ -1037,6 +1035,7 @@ function InjectAll(token) {
             checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "InjectAll";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
+            checkNamedDecorator(dependency, target, propertyKey, parameterIndex);
         });
     };
 }
@@ -1059,21 +1058,23 @@ function InjectAll(token) {
  *
  * @__NO_SIDE_EFFECTS__
  */ function Named(name) {
-    if (!name.trim()) {
-        assert(false, "the @Named qualifier cannot be empty or blank");
-    }
+    check(name.trim(), "the @Named qualifier cannot be empty or blank");
     return function(target, propertyKey, parameterIndex) {
         if (parameterIndex === undefined) {
             // The decorator has been applied to the class
             const ctor = target;
             const metadata = getMetadata(ctor);
-            assert(!metadata.name, `a @Named('${metadata.name}') qualifier has already been applied to ${ctor.name}`);
+            check(metadata.name === undefined, `multiple @Named decorators on class ${ctor.name}, but only one is allowed`);
             metadata.name = name;
         } else {
             // The decorator has been applied to a method parameter
             updateParameterMetadata("Named", target, propertyKey, parameterIndex, (dependency)=>{
-                assert(!dependency.name, `a @Named('${dependency.name}') qualifier has already been applied to the parameter`);
+                check(dependency.name === undefined, ()=>{
+                    const location = getLocation(target, propertyKey, parameterIndex);
+                    return `multiple @Named decorators on ${location}, but only one is allowed`;
+                });
                 dependency.name = name;
+                checkNamedDecorator(dependency, target, propertyKey, parameterIndex);
             });
         }
     };
@@ -1095,6 +1096,7 @@ function OptionalAll(token) {
             checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "OptionalAll";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
+            checkNamedDecorator(dependency, target, propertyKey, parameterIndex);
         });
     };
 }
@@ -1124,7 +1126,7 @@ function OptionalAll(token) {
     return function(Class) {
         const metadata = getMetadata(Class);
         const currentScope = metadata.scope;
-        assert(!currentScope || currentScope.value === scope, ()=>{
+        check(!currentScope || currentScope.value === scope, ()=>{
             const { value, appliedBy } = currentScope;
             const by = appliedBy === "Scoped" ? `another @${appliedBy} decorator` : `@${appliedBy}`;
             return `class ${Class.name}: Scope.${value} was already set by ${by},\n  ` + `but @Scoped is trying to set a conflicting Scope.${scope}.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;