@lppedd/di-wise-neo 0.11.1 → 0.12.0

package/dist/cjs/index.js

@@ -171,10 +171,9 @@ function injectBy(thisArg, token, name) {
     if (!currentFrame) {
         return inject(token, name);
     }
-    const currentRef = {
+    const cleanup = resolution.dependents.set(currentFrame.provider, {
         current: thisArg
-    };
-    const cleanup = resolution.dependents.set(currentFrame.provider, currentRef);
+    });
     try {
         return inject(token, name);
     } finally{
@@ -264,8 +263,8 @@ function getMetadata(Class) {
  * This allows libraries or consumers that manipulate constructors, such as through
  * class decorators, to inform the DI system about the real "identity" of a class.
  *
- * @param transformedClass The constructor function returned by a class decorator or factory.
- * @param originalClass The original constructor function.
+ * @param transformedClass - The constructor function returned by a class decorator or factory.
+ * @param originalClass - The original constructor function.
  *
  * @remarks
  * This API affects the core class identity resolution mechanism of the DI system.
@@ -280,7 +279,7 @@ const metadataMap = new WeakMap();
 
 function optional(token, name) {
     const context = ensureInjectionContext("optional()");
-    return context.container.resolve(token, true, name);
+    return context.container.tryResolve(token, name);
 }
 function optionalBy(thisArg, token, name) {
     const context = ensureInjectionContext("optionalBy()");
@@ -289,10 +288,9 @@ function optionalBy(thisArg, token, name) {
     if (!currentFrame) {
         return optional(token, name);
     }
-    const currentRef = {
+    const cleanup = resolution.dependents.set(currentFrame.provider, {
         current: thisArg
-    };
-    const cleanup = resolution.dependents.set(currentFrame.provider, currentRef);
+    });
     try {
         return optional(token, name);
     } finally{
@@ -302,7 +300,7 @@ function optionalBy(thisArg, token, name) {
 
 function optionalAll(token) {
     const context = ensureInjectionContext("optionalAll()");
-    return context.container.resolveAll(token, true);
+    return context.container.tryResolveAll(token);
 }
 
 // @internal
@@ -323,9 +321,20 @@ function isExistingProvider(provider) {
 }
 
 const Scope = {
-    Transient: "Transient",
-    Resolution: "Resolution",
-    Container: "Container"
+    /**
+   * Creates a new value every time the token is resolved.
+   */ Transient: "Transient",
+    /**
+   * Creates and caches a single value per token resolution graph.
+   *
+   * The same value is reused during a single resolution request and is subsequently discarded.
+   */ Resolution: "Resolution",
+    /**
+   * Creates and caches a single value per container.
+   *
+   * If the value is not found in the current container, it is looked up in the parent container,
+   * and so on. It effectively behaves like a _singleton_ scope but allows container-specific overrides.
+   */ Container: "Container"
 };
 
 /**
@@ -648,40 +657,21 @@ function isDisposable(value) {
         }
         return Array.from(values);
     }
-    resolve(token, optionalOrName, name) {
+    resolve(token, name) {
         this.checkDisposed();
-        let localOptional;
-        let localName;
-        if (typeof optionalOrName === "string") {
-            localName = optionalOrName;
-        } else {
-            localOptional = optionalOrName;
-            localName = name;
-        }
-        let registration = this.myTokenRegistry.get(token, localName);
-        if (!registration && isConstructor(token)) {
-            registration = this.autoRegisterClass(token, localName);
-        }
-        return this.resolveRegistration(token, registration, localOptional, localName);
+        return this.resolveToken(token, name, false);
     }
-    resolveAll(token, optional) {
+    tryResolve(token, name) {
         this.checkDisposed();
-        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 && !optional) {
-            throwUnregisteredError([
-                token
-            ]);
-        }
-        return registrations //
-        .map((registration)=>this.resolveRegistration(token, registration, optional)).filter((value)=>value != null);
+        return this.resolveToken(token, name, true);
+    }
+    resolveAll(token) {
+        this.checkDisposed();
+        return this.resolveAllToken(token, false);
+    }
+    tryResolveAll(token) {
+        this.checkDisposed();
+        return this.resolveAllToken(token, true);
     }
     dispose() {
         if (this.myDisposed) {
@@ -708,6 +698,30 @@ function isDisposable(value) {
         // Allow values to be GCed
         disposedRefs.clear();
     }
+    resolveToken(token, name, optional) {
+        let registration = this.myTokenRegistry.get(token, name);
+        if (!registration && isConstructor(token)) {
+            registration = this.autoRegisterClass(token, name);
+        }
+        return this.resolveRegistration(token, registration, optional, name)?.value;
+    }
+    resolveAllToken(token, optional) {
+        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 && !optional) {
+            throwUnregisteredError([
+                token
+            ]);
+        }
+        return registrations.map((registration)=>this.resolveRegistration(token, registration, optional)).filter((result)=>result !== undefined).map((result)=>result.value);
+    }
     resolveRegistration(token, registration, optional, name) {
         const aliases = [];
         while(registration && isExistingProvider(registration.provider)){
@@ -741,7 +755,9 @@ function isDisposable(value) {
             ]);
         }
         try {
-            return this.resolveProviderValue(token, registration);
+            return {
+                value: this.resolveProviderValue(token, registration)
+            };
         } catch (e) {
             throwResolutionError([
                 token,
@@ -917,9 +933,9 @@ function isDisposable(value) {
             case "InjectAll":
                 return instance ? injectAll(token) : this.resolveAll(token);
             case "Optional":
-                return instance ? optionalBy(instance, token, name) : this.resolve(token, true, name);
+                return instance ? optionalBy(instance, token, name) : this.tryResolve(token, name);
             case "OptionalAll":
-                return instance ? optionalAll(token) : this.resolveAll(token, true);
+                return instance ? optionalAll(token) : this.tryResolveAll(token);
         }
     }
     checkDisposed() {
@@ -937,7 +953,7 @@ function isDisposable(value) {
 }
 
 /**
- * Class decorator that enables auto-registration of an unregistered class,
+ * Class decorator that enables auto-registration of an unregistered class
  * when the class is first resolved from the container.
  *
  * @example
@@ -1245,14 +1261,14 @@ function OptionalAll(token) {
         injectAll: (token)=>runInContext(()=>injectAll(token)),
         optional: (token, name)=>runInContext(()=>optional(token, name)),
         optionalAll: (token)=>runInContext(()=>optionalAll(token)),
-        runInContext
+        runInContext: runInContext
     };
 }, "Injector");
 
 /**
  * Applies middleware functions to a container.
  *
- * Middlewares are applied in array order, but execute in reverse order.
+ * Middlewares are applied in array order but execute in reverse order.
  *
  * @example
  * ```ts