@lppedd/di-wise-neo 0.9.3 → 0.10.0

package/README.md

@@ -168,14 +168,9 @@ registrar.registerCommand("my.command", () => { console.log("hey!"); });
 
 ## Container scopes
 
-The [Container][source-container] supports four **scope** types that determine how and when
+The [Container][source-container] supports three **scope** types that determine how and when
 values are cached and reused.
 
-### Inherited
-
-Inherits the scope from the requesting (dependent) token.  
-If there is no dependent (i.e., during top-level resolution), it behaves like **Transient**.
-
 ### Transient
 
 Creates a new value every time the dependency is resolved, which means values are never cached.
@@ -184,6 +179,11 @@ Creates a new value every time the dependency is resolved, which means values ar
 - a factory function registered via `FactoryProvider` is invoked on each resolution
 - a value registered via `ValueProvider` is always returned as-is
 
+> [!NOTE]
+> When a **Transient** or **Resolution**-scoped value is injected into a **Container**-scoped
+> instance, it effectively inherits the lifecycle of that instance. The value will live as long
+> as the containing instance, even though it is not cached by the container itself.
+
 ### Resolution
 
 Creates and caches a single value per resolution graph.  

package/dist/cjs/index.d.ts

@@ -155,7 +155,6 @@ interface ExistingProvider<Value> {
 type Provider<Value = any> = ClassProvider<Value & object> | FactoryProvider<Value> | ValueProvider<Value> | ExistingProvider<Value>;
 
 declare const Scope: {
-    readonly Inherited: "Inherited";
     readonly Transient: "Transient";
     readonly Resolution: "Resolution";
     readonly Container: "Container";
@@ -203,7 +202,7 @@ interface ContainerOptions {
     /**
      * The default scope for registrations.
      *
-     * @defaultValue Scope.Inherited
+     * @defaultValue Scope.Transient
      */
     readonly defaultScope: Scope;
 }

package/dist/cjs/index.js

@@ -17,17 +17,17 @@ function throwUnregisteredError(token, name) {
 }
 // @internal
 function throwExistingUnregisteredError(token, cause) {
-    const message = tag(`failed to resolve token ${getTokenName(token)}`);
-    throw isError(cause) ? new Error(`${message}\n  [cause] ${untag(cause.message)}`, {
+    const msg = tag(`failed to resolve token ${getTokenName(token)}`);
+    throw isError(cause) ? new Error(`${msg}\n  [cause] ${untag(cause.message)}`, {
         cause
-    }) : new Error(`${message}\n  [cause] the aliased token ${getTokenName(cause)} is not registered`);
+    }) : new Error(`${msg}\n  [cause] the aliased token ${getTokenName(cause)} is not registered`);
 }
 // @internal
 function throwParameterResolutionError(ctor, methodKey, dependency, cause) {
     const location = getLocation(ctor, methodKey);
-    const token = dependency.tokenRef.getRefToken();
-    const message = tag(`failed to resolve dependency for ${location}(parameter #${dependency.index}: ${token.name})`);
-    throw new Error(`${message}\n  [cause] ${untag(cause.message)}`, {
+    const tokenName = getTokenName(dependency.tokenRef.getRefToken());
+    const msg = tag(`failed to resolve dependency for ${location}(parameter #${dependency.index}: ${tokenName})`);
+    throw new Error(`${msg}\n  [cause] ${untag(cause.message)}`, {
         cause
     });
 }
@@ -298,7 +298,6 @@ function isExistingProvider(provider) {
 }
 
 const Scope = {
-    Inherited: "Inherited",
     Transient: "Transient",
     Resolution: "Resolution",
     Container: "Container"
@@ -375,11 +374,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);
     }
@@ -475,7 +477,7 @@ function isDisposable(value) {
         this.myParent = parent;
         this.myOptions = {
             autoRegister: false,
-            defaultScope: Scope.Inherited,
+            defaultScope: Scope.Transient,
             ...options
         };
         this.myTokenRegistry = new TokenRegistry(this.myParent?.myTokenRegistry);
@@ -594,7 +596,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,
@@ -741,16 +743,15 @@ function isDisposable(value) {
         }
         const resolution = context.resolution;
         const provider = registration.provider;
-        const options = registration.options;
         if (resolution.stack.has(provider)) {
             const dependentRef = resolution.dependents.get(provider);
             check(dependentRef, ()=>{
-                const path = resolution.tokenStack.map((t)=>t.name).join(" → ");
-                return `circular dependency detected while resolving ${path} → ${token.name}`;
+                const path = resolution.tokenStack.map(getTokenName).concat(getTokenName(token)).join(" → ");
+                return `circular dependency detected while resolving ${path}`;
             });
             return dependentRef.current;
         }
-        const scope = this.resolveScope(options?.scope, context);
+        const scope = registration.options?.scope ?? this.myOptions.defaultScope;
         const cleanups = [
             provideInjectionContext(context),
             resolution.tokenStack.push(token) && (()=>resolution.tokenStack.pop()),
@@ -797,13 +798,6 @@ function isDisposable(value) {
             cleanups.forEach((cleanup)=>cleanup && cleanup());
         }
     }
-    resolveScope(scope = this.myOptions.defaultScope, context = useInjectionContext()) {
-        if (scope === Scope.Inherited) {
-            const dependentFrame = context?.resolution.stack.peek();
-            return dependentFrame?.scope || Scope.Transient;
-        }
-        return scope;
-    }
     resolveCtorDependencies(registration) {
         const dependencies = registration.dependencies;
         if (dependencies) {
@@ -881,7 +875,7 @@ function isDisposable(value) {
  * Creates a new container.
  */ function createContainer(options = {
     autoRegister: false,
-    defaultScope: Scope.Inherited
+    defaultScope: Scope.Transient
 }) {
     return new ContainerImpl(undefined, options);
 }
@@ -1180,22 +1174,15 @@ function OptionalAll(token) {
  * ```
  */ const Injector = /*@__PURE__*/ build(()=>{
     const context = ensureInjectionContext("Injector factory");
-    const resolution = context.resolution;
-    const dependentFrame = resolution.stack.peek();
-    const dependentRef = dependentFrame && resolution.dependents.get(dependentFrame.provider);
     const runInContext = (fn)=>{
         if (useInjectionContext()) {
             return fn();
         }
-        const cleanups = [
-            provideInjectionContext(context),
-            dependentFrame && resolution.stack.push(dependentFrame.provider, dependentFrame),
-            dependentRef && resolution.dependents.set(dependentFrame.provider, dependentRef)
-        ];
+        const cleanup = provideInjectionContext(context);
         try {
             return fn();
         } finally{
-            cleanups.forEach((cleanup)=>cleanup?.());
+            cleanup();
         }
     };
     return {