@lppedd/di-wise-neo 0.9.0 → 0.9.2

package/dist/es/index.mjs

@@ -26,7 +26,7 @@ function isConstructor(token) {
 }
 
 // @internal
-function assert(condition, message) {
+function check(condition, message) {
     if (!condition) {
         throw new Error(tag(typeof message === "string" ? message : message()));
     }
@@ -58,13 +58,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) {
@@ -75,7 +68,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,
@@ -87,7 +80,7 @@ class KeyedStack {
         };
     }
     constructor(){
-        this.myEntries = new Array();
+        this.myEntries = [];
         this.myKeys = new WeakSet();
     }
 }
@@ -106,7 +99,7 @@ class WeakRefMap {
         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);
@@ -120,6 +113,7 @@ class WeakRefMap {
 // @internal
 function createResolution() {
     return {
+        tokenStack: [],
         stack: new KeyedStack(),
         values: new WeakRefMap(),
         dependents: new WeakRefMap()
@@ -130,7 +124,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 +354,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 +414,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 ?? [];
     }
@@ -555,13 +549,13 @@ function isDisposable(value) {
             }
             // Eager-instantiate only if the class is container-scoped
             if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                this.resolveProviderValue(registration, registration.provider);
+                this.resolveProviderValue(Class, registration);
             }
         } else {
             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 = {
@@ -578,11 +572,11 @@ function isDisposable(value) {
                 this.myTokenRegistry.set(token, registration);
                 // Eager-instantiate only if the provided class is container-scoped
                 if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                    this.resolveProviderValue(registration, registration.provider);
+                    this.resolveProviderValue(token, registration);
                 }
             } 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,
@@ -668,17 +662,15 @@ function isDisposable(value) {
     }
     resolveRegistration(token, registration, name) {
         let currRegistration = registration;
-        let currProvider = currRegistration.provider;
-        while(isExistingProvider(currProvider)){
-            const targetToken = currProvider.useExisting;
+        while(isExistingProvider(currRegistration.provider)){
+            const targetToken = currRegistration.provider.useExisting;
             currRegistration = this.myTokenRegistry.get(targetToken, name);
             if (!currRegistration) {
                 throwExistingUnregisteredError(token, targetToken);
             }
-            currProvider = currRegistration.provider;
         }
         try {
-            return this.resolveProviderValue(currRegistration, currProvider);
+            return this.resolveProviderValue(token, currRegistration);
         } catch (e) {
             // If we were trying to resolve a token registered via ExistingProvider,
             // we must add the cause of the error to the message
@@ -705,26 +697,24 @@ function isDisposable(value) {
         }
         return undefined;
     }
-    resolveProviderValue(registration, provider) {
-        assert(registration.provider === provider, "internal error: mismatching provider");
+    resolveProviderValue(token, registration) {
+        const provider = registration.provider;
         if (isClassProvider(provider)) {
             const Class = provider.useClass;
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return this.resolveScopedValue(registration, (args)=>new Class(...args));
+            return this.resolveScopedValue(token, registration, (args)=>new Class(...args));
         }
         if (isFactoryProvider(provider)) {
             const factory = provider.useFactory;
-            return this.resolveScopedValue(registration, factory);
+            return this.resolveScopedValue(token, registration, factory);
         }
         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) {
+    resolveScopedValue(token, registration, factory) {
         let context = useInjectionContext();
         if (!context || context.container !== this) {
             context = {
@@ -737,12 +727,16 @@ 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, ()=>{
+                const tokenStack = resolution.tokenStack.map((t)=>t.name).concat(token.name).join(" → ");
+                return `circular dependency detected while resolving ${tokenStack}`;
+            });
             return dependentRef.current;
         }
         const scope = this.resolveScope(options?.scope, context);
         const cleanups = [
             provideInjectionContext(context),
+            resolution.tokenStack.push(token) && (()=>resolution.tokenStack.pop()),
             !isBuilder(provider) && resolution.stack.push(provider, {
                 provider,
                 scope
@@ -796,13 +790,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}`;
                 });
@@ -826,7 +820,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){
@@ -836,7 +830,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}`;
                 });
@@ -860,7 +854,7 @@ function isDisposable(value) {
         return instance;
     }
     checkDisposed() {
-        assert(!this.myDisposed, "the container is disposed");
+        check(!this.myDisposed, "the container is disposed");
     }
 }
 
@@ -916,7 +910,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.`;
         });
@@ -941,7 +935,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;
         }
     };
@@ -961,7 +955,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
@@ -981,11 +975,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) {
@@ -1023,6 +1036,7 @@ function InjectAll(token) {
             checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "InjectAll";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
+            checkNamedDecorator(dependency, target, propertyKey, parameterIndex);
         });
     };
 }
@@ -1045,21 +1059,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);
             });
         }
     };
@@ -1081,6 +1097,7 @@ function OptionalAll(token) {
             checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "OptionalAll";
             dependency.tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
+            checkNamedDecorator(dependency, target, propertyKey, parameterIndex);
         });
     };
 }
@@ -1110,7 +1127,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.`;