@lppedd/di-wise-neo 0.9.2 → 0.9.4

package/dist/cjs/index.js

@@ -1,32 +1,5 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/**
- * 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 check(condition, message) {
     if (!condition) {
@@ -39,18 +12,35 @@ function expectNever(value) {
 }
 // @internal
 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}`));
+    throw new Error(tag(`unregistered token ${getTokenName(token)}${spec}`));
 }
 // @internal
-function throwExistingUnregisteredError(sourceToken, targetTokenOrError) {
-    let message = tag(`token resolution error encountered while resolving ${sourceToken.name}`);
-    message += isError(targetTokenOrError) ? `\n  [cause] ${untag(targetTokenOrError.message)}` : `\n  [cause] the aliased token ${targetTokenOrError.name} is not registered`;
-    throw new Error(message);
+function throwExistingUnregisteredError(token, cause) {
+    const message = tag(`failed to resolve token ${getTokenName(token)}`);
+    throw isError(cause) ? new Error(`${message}\n  [cause] ${untag(cause.message)}`, {
+        cause
+    }) : new Error(`${message}\n  [cause] the aliased token ${getTokenName(cause)} is not registered`);
+}
+// @internal
+function throwParameterResolutionError(ctor, methodKey, dependency, cause) {
+    const location = getLocation(ctor, methodKey);
+    const tokenName = getTokenName(dependency.tokenRef.getRefToken());
+    const message = tag(`failed to resolve dependency for ${location}(parameter #${dependency.index}: ${tokenName})`);
+    throw new Error(`${message}\n  [cause] ${untag(cause.message)}`, {
+        cause
+    });
+}
+// @internal
+function getLocation(ctor, methodKey) {
+    const ctorName = ctor.name || "<unnamed>";
+    return methodKey ? `${ctorName}.${String(methodKey)}` : ctorName;
+}
+// @internal
+function getTokenName(token) {
+    return token.name || "<unnamed>";
 }
 function isError(value) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     return value && value.stack && value.message && typeof value.message === "string";
 }
 function tag(message) {
@@ -176,7 +166,7 @@ function injectAll(token) {
 class Metadata {
     constructor(Class){
         this.dependencies = {
-            constructor: [],
+            ctor: [],
             methods: new Map()
         };
         this.tokensRef = {
@@ -192,15 +182,15 @@ class Metadata {
     set name(name) {
         this.provider.name = name;
     }
-    getConstructorDependency(index) {
-        const i = this.dependencies.constructor.findIndex((d)=>d.index === index);
+    getCtorDependency(index) {
+        const i = this.dependencies.ctor.findIndex((d)=>d.index === index);
         if (i > -1) {
-            return this.dependencies.constructor[i];
+            return this.dependencies.ctor[i];
         }
         const dependency = {
             index: index
         };
-        this.dependencies.constructor.push(dependency);
+        this.dependencies.ctor.push(dependency);
         return dependency;
     }
     getMethodDependency(method, index) {
@@ -314,6 +304,33 @@ 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){
@@ -328,9 +345,9 @@ function getTypeName(value) {
                 }
                 const proto = Object.getPrototypeOf(value);
                 if (proto && proto !== Object.prototype) {
-                    const constructor = proto.constructor;
-                    if (typeof constructor === "function" && constructor.name) {
-                        return constructor.name;
+                    const ctor = proto.constructor;
+                    if (typeof ctor === "function" && ctor.name) {
+                        return ctor.name;
                     }
                 }
             }
@@ -358,11 +375,14 @@ class TokenRegistry {
     set(token, registration) {
         check(!internals.has(token), `cannot register reserved token ${token.name}`);
         let registrations = this.myMap.get(token);
-        if (!registrations) {
+        if (registrations) {
+            const name = registration.name;
+            if (name !== undefined) {
+                const existing = registrations.filter((r)=>r.name === name);
+                check(existing.length === 0, `token ${getTokenName(token)} with name '${name}' is already registered`);
+            }
+        } else {
             this.myMap.set(token, registrations = []);
-        } else if (registration.name !== undefined) {
-            const existing = registrations.filter((r)=>r.name === registration.name);
-            check(existing.length === 0, `a ${token.name} token named '${registration.name}' is already registered`);
         }
         registrations.push(registration);
     }
@@ -446,7 +466,6 @@ const builders = new WeakSet();
 // @internal
 // @internal
 function isDisposable(value) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     return value && typeof value === "object" && typeof value.dispose === "function";
 }
 
@@ -557,7 +576,7 @@ function isDisposable(value) {
             const [token, provider, options] = args;
             const existingProvider = isExistingProvider(provider);
             const name = existingProvider ? undefined : provider.name;
-            check(name === undefined || name.trim(), "the provider name qualifier cannot be empty or blank");
+            check(name === undefined || name.trim(), `the name qualifier for token ${getTokenName(token)} must not be empty`);
             if (isClassProvider(provider)) {
                 const metadata = getMetadata(provider.useClass);
                 const registration = {
@@ -578,7 +597,7 @@ function isDisposable(value) {
                 }
             } else {
                 if (existingProvider) {
-                    check(token !== provider.useExisting, `the useExisting token ${token.name} cannot be the same as the token being registered`);
+                    check(token !== provider.useExisting, `token ${getTokenName(token)} cannot alias itself via useExisting`);
                 }
                 this.myTokenRegistry.set(token, {
                     name: name,
@@ -703,7 +722,6 @@ function isDisposable(value) {
         const provider = registration.provider;
         if (isClassProvider(provider)) {
             const Class = provider.useClass;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return this.resolveScopedValue(token, registration, (args)=>new Class(...args));
         }
         if (isFactoryProvider(provider)) {
@@ -730,8 +748,8 @@ function isDisposable(value) {
         if (resolution.stack.has(provider)) {
             const dependentRef = resolution.dependents.get(provider);
             check(dependentRef, ()=>{
-                const tokenStack = resolution.tokenStack.map((t)=>t.name).concat(token.name).join(" → ");
-                return `circular dependency detected while resolving ${tokenStack}`;
+                const path = resolution.tokenStack.map(getTokenName).join(" → ");
+                return `circular dependency detected while resolving ${path} → ${getTokenName(token)}`;
             });
             return dependentRef.current;
         }
@@ -752,8 +770,8 @@ function isDisposable(value) {
                         if (valueRef) {
                             return valueRef.current;
                         }
-                        const args = this.resolveConstructorDependencies(registration);
-                        const value = this.injectDependencies(registration, factory(args));
+                        const args = this.resolveCtorDependencies(registration);
+                        const value = this.injectMethodDependencies(registration, factory(args));
                         registration.value = {
                             current: value
                         };
@@ -765,8 +783,8 @@ function isDisposable(value) {
                         if (valueRef) {
                             return valueRef.current;
                         }
-                        const args = this.resolveConstructorDependencies(registration);
-                        const value = this.injectDependencies(registration, factory(args));
+                        const args = this.resolveCtorDependencies(registration);
+                        const value = this.injectMethodDependencies(registration, factory(args));
                         resolution.values.set(provider, {
                             current: value
                         });
@@ -774,8 +792,8 @@ function isDisposable(value) {
                     }
                 case Scope.Transient:
                     {
-                        const args = this.resolveConstructorDependencies(registration);
-                        return this.injectDependencies(registration, factory(args));
+                        const args = this.resolveCtorDependencies(registration);
+                        return this.injectMethodDependencies(registration, factory(args));
                     }
             }
         } finally{
@@ -789,72 +807,74 @@ function isDisposable(value) {
         }
         return scope;
     }
-    resolveConstructorDependencies(registration) {
+    resolveCtorDependencies(registration) {
         const dependencies = registration.dependencies;
         if (dependencies) {
             check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
-            const ctorDeps = dependencies.constructor.filter((d)=>d.appliedBy);
+            const ctorDeps = dependencies.ctor.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;
                 check(ctor.length === ctorDeps.length, ()=>{
-                    const msg = `expected ${ctor.length} decorated constructor parameters in ${ctor.name}`;
+                    const location = getLocation(ctor);
+                    const msg = `${location} expected ${ctor.length} decorated constructor parameters`;
                     return msg + `, but found ${ctorDeps.length}`;
                 });
-                return ctorDeps.sort((a, b)=>a.index - b.index).map((dep)=>{
-                    const token = dep.tokenRef.getRefToken();
-                    switch(dep.appliedBy){
-                        case "Inject":
-                            return this.resolve(token, dep.name);
-                        case "InjectAll":
-                            return this.resolveAll(token);
-                        case "Optional":
-                            return this.resolve(token, true, dep.name);
-                        case "OptionalAll":
-                            return this.resolveAll(token, true);
-                    }
-                });
+                return this.resolveArgs(ctorDeps, ctor);
             }
         }
         return [];
     }
-    injectDependencies(registration, instance) {
+    injectMethodDependencies(registration, instance) {
         const dependencies = registration.dependencies;
         if (dependencies) {
             check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
             const ctor = registration.provider.useClass;
             // Perform method injection
             for (const entry of dependencies.methods){
-                const key = entry[0];
+                const methodKey = entry[0];
                 const methodDeps = entry[1].filter((d)=>d.appliedBy);
                 // Let's check if all necessary method parameters are decorated.
                 // If not, we cannot safely invoke the method.
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                const method = instance[key];
+                const method = instance[methodKey];
                 check(methodDeps.length === method.length, ()=>{
-                    const msg = `expected ${method.length} decorated method parameters`;
-                    return msg + ` in ${ctor.name}.${String(key)}, but found ${methodDeps.length}`;
+                    const location = getLocation(ctor, methodKey);
+                    const msg = `${location} expected ${method.length} decorated method parameters`;
+                    return msg + `, but found ${methodDeps.length}`;
                 });
-                const args = methodDeps.sort((a, b)=>a.index - b.index).map((dep)=>{
-                    const token = dep.tokenRef.getRefToken();
-                    switch(dep.appliedBy){
-                        case "Inject":
-                            return injectBy(instance, token, dep.name);
-                        case "InjectAll":
-                            return injectAll(token);
-                        case "Optional":
-                            return optionalBy(instance, token, dep.name);
-                        case "OptionalAll":
-                            return optionalAll(token);
-                    }
-                });
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                const args = this.resolveArgs(methodDeps, ctor, instance, methodKey);
                 method.bind(instance)(...args);
             }
         }
         return instance;
     }
+    resolveArgs(deps, ctor, instance, methodKey) {
+        const sortedDeps = deps.sort((a, b)=>a.index - b.index);
+        const args = [];
+        for (const dep of sortedDeps){
+            try {
+                args.push(this.resolveDependency(dep, instance));
+            } catch (e) {
+                throwParameterResolutionError(ctor, methodKey, dep, e);
+            }
+        }
+        return args;
+    }
+    resolveDependency(dependency, instance) {
+        const token = dependency.tokenRef.getRefToken();
+        const name = dependency.name;
+        switch(dependency.appliedBy){
+            case "Inject":
+                return instance ? injectBy(instance, token, name) : this.resolve(token, name);
+            case "InjectAll":
+                return instance ? injectAll(token) : this.resolveAll(token);
+            case "Optional":
+                return instance ? optionalBy(instance, token, name) : this.resolve(token, true, name);
+            case "OptionalAll":
+                return instance ? optionalAll(token) : this.resolveAll(token, true);
+        }
+    }
     checkDisposed() {
         check(!this.myDisposed, "the container is disposed");
     }
@@ -910,11 +930,13 @@ function isDisposable(value) {
  * @__NO_SIDE_EFFECTS__
  */ function EagerInstantiate() {
     return function(Class) {
-        const metadata = getMetadata(Class);
+        const ctor = Class;
+        const metadata = getMetadata(ctor);
         const currentScope = metadata.scope;
         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.`;
+            const className = getTokenName(ctor);
+            return `class ${className}: 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.`;
         });
         metadata.eagerInstantiate = true;
         metadata.scope = {
@@ -944,30 +966,28 @@ function forwardRef(token) {
 }
 // @internal
 function isTokensRef(value) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     return value && typeof value === "object" && typeof value.getRefTokens === "function";
 }
 // @internal
 function isTokenRef(value) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     return value && typeof value === "object" && typeof value.getRefToken === "function";
 }
 
 // @internal
-function updateParameterMetadata(decorator, target, propertyKey, parameterIndex, updateFn) {
+function updateParameterMetadata(decorator, target, methodKey, parameterIndex, updateFn) {
     // Error out immediately if the decorator has been applied to a static method
-    if (propertyKey !== undefined && typeof target === "function") {
-        check(false, `@${decorator} cannot be used on static method ${target.name}.${String(propertyKey)}`);
+    if (methodKey !== undefined && typeof target === "function") {
+        check(false, `@${decorator} cannot be used on static method ${target.name}.${String(methodKey)}`);
     }
-    if (propertyKey === undefined) {
+    if (methodKey === undefined) {
         // Constructor
         const metadata = getMetadata(target);
-        const dependency = metadata.getConstructorDependency(parameterIndex);
+        const dependency = metadata.getCtorDependency(parameterIndex);
         updateFn(dependency);
     } else {
         // Instance method
         const metadata = getMetadata(target.constructor);
-        const dependency = metadata.getMethodDependency(propertyKey, parameterIndex);
+        const dependency = metadata.getMethodDependency(methodKey, parameterIndex);
         updateFn(dependency);
     }
 }
@@ -976,30 +996,30 @@ function updateParameterMetadata(decorator, target, propertyKey, parameterIndex,
 // understand which one "wins", unless the user is aware of the decorator evaluation order.
 //
 // @internal
-function checkSingleDecorator(dependency, target, propertyKey, parameterIndex) {
+function checkSingleDecorator(dependency, target, methodKey, parameterIndex) {
     check(dependency.appliedBy === undefined, ()=>{
-        const location = getLocation(target, propertyKey, parameterIndex);
-        return `multiple injection decorators on ${location}, but only one is allowed`;
+        const param = describeParam(target, methodKey, parameterIndex);
+        return `multiple injection decorators on ${param}, 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) {
+function checkNamedDecorator(dependency, target, methodKey, 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}`;
+        const param = describeParam(target, methodKey, parameterIndex);
+        return `@Named has no effect on ${param} 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 describeParam(target, methodKey, parameterIndex) {
+    const location = methodKey === undefined ? target.name : `${target.constructor.name}.${String(methodKey)}`;
+    return `${location}(parameter #${parameterIndex})`;
 }
 
 function Inject(token) {
@@ -1061,20 +1081,21 @@ function InjectAll(token) {
  *
  * @__NO_SIDE_EFFECTS__
  */ function Named(name) {
-    check(name.trim(), "the @Named qualifier cannot be empty or blank");
+    check(name.trim(), "the @Named qualifier must not be empty");
     return function(target, propertyKey, parameterIndex) {
         if (parameterIndex === undefined) {
             // The decorator has been applied to the class
             const ctor = target;
             const metadata = getMetadata(ctor);
-            check(metadata.name === undefined, `multiple @Named decorators on class ${ctor.name}, but only one is allowed`);
+            const className = getTokenName(ctor);
+            check(metadata.name === undefined, `multiple @Named decorators on class ${className}, but only one is allowed`);
             metadata.name = name;
         } else {
             // The decorator has been applied to a method parameter
             updateParameterMetadata("Named", target, propertyKey, parameterIndex, (dependency)=>{
                 check(dependency.name === undefined, ()=>{
-                    const location = getLocation(target, propertyKey, parameterIndex);
-                    return `multiple @Named decorators on ${location}, but only one is allowed`;
+                    const param = describeParam(target, propertyKey, parameterIndex);
+                    return `multiple @Named decorators on ${param}, but only one is allowed`;
                 });
                 dependency.name = name;
                 checkNamedDecorator(dependency, target, propertyKey, parameterIndex);
@@ -1127,12 +1148,14 @@ function OptionalAll(token) {
  * @__NO_SIDE_EFFECTS__
  */ function Scoped(scope) {
     return function(Class) {
-        const metadata = getMetadata(Class);
+        const ctor = Class;
+        const metadata = getMetadata(ctor);
         const currentScope = metadata.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.`;
+            const className = getTokenName(ctor);
+            return `class ${className}: 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.`;
         });
         metadata.scope = {
             value: scope,
@@ -1214,10 +1237,7 @@ function OptionalAll(token) {
         use (key, wrap) {
             // We need to bind the 'this' context of the function to the container
             // before passing it to the middleware wrapper.
-            //
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
             const fn = container[key].bind(container);
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             container[key] = wrap(fn);
             return composer;
         }