@lppedd/di-wise-neo 0.9.4 → 0.10.0

package/dist/es/index.d.mts

@@ -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/es/index.mjs

@@ -15,17 +15,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 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)}`, {
+    const msg = tag(`failed to resolve dependency for ${location}(parameter #${dependency.index}: ${tokenName})`);
+    throw new Error(`${msg}\n  [cause] ${untag(cause.message)}`, {
         cause
     });
 }
@@ -296,7 +296,6 @@ function isExistingProvider(provider) {
 }
 
 const Scope = {
-    Inherited: "Inherited",
     Transient: "Transient",
     Resolution: "Resolution",
     Container: "Container"
@@ -476,7 +475,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);
@@ -742,16 +741,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(getTokenName).join(" → ");
-                return `circular dependency detected while resolving ${path} → ${getTokenName(token)}`;
+                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()),
@@ -798,13 +796,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) {
@@ -882,7 +873,7 @@ function isDisposable(value) {
  * Creates a new container.
  */ function createContainer(options = {
     autoRegister: false,
-    defaultScope: Scope.Inherited
+    defaultScope: Scope.Transient
 }) {
     return new ContainerImpl(undefined, options);
 }
@@ -1181,22 +1172,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 {