@lppedd/di-wise-neo 0.9.0 → 0.9.1

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,
@@ -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);
@@ -130,7 +123,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 +353,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 +413,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 +554,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 +575,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,
@@ -706,7 +699,7 @@ function isDisposable(value) {
         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
@@ -719,9 +712,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) {
@@ -737,7 +728,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);
@@ -796,13 +787,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 +817,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 +827,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 +851,7 @@ function isDisposable(value) {
         return instance;
     }
     checkDisposed() {
-        assert(!this.myDisposed, "the container is disposed");
+        check(!this.myDisposed, "the container is disposed");
     }
 }
 
@@ -916,7 +907,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 +932,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 +952,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 +972,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 +1033,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 +1056,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 +1094,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 +1124,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.`;