@lppedd/di-wise-neo 0.8.1 → 0.9.0

package/dist/cjs/index.js

@@ -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) {
@@ -104,6 +105,7 @@ class WeakRefMap {
             }
             this.myMap.delete(key);
         }
+        return undefined;
     }
     set(key, value) {
         invariant(!this.get(key));
@@ -615,29 +617,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,37 +690,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");