@lppedd/di-wise-neo 0.9.1 → 0.9.2

package/dist/es/index.mjs

@@ -80,7 +80,7 @@ class KeyedStack {
         };
     }
     constructor(){
-        this.myEntries = new Array();
+        this.myEntries = [];
         this.myKeys = new WeakSet();
     }
 }
@@ -113,6 +113,7 @@ class WeakRefMap {
 // @internal
 function createResolution() {
     return {
+        tokenStack: [],
         stack: new KeyedStack(),
         values: new WeakRefMap(),
         dependents: new WeakRefMap()
@@ -548,7 +549,7 @@ function isDisposable(value) {
             }
             // Eager-instantiate only if the class is container-scoped
             if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                this.resolveProviderValue(registration, registration.provider);
+                this.resolveProviderValue(Class, registration);
             }
         } else {
             const [token, provider, options] = args;
@@ -571,7 +572,7 @@ function isDisposable(value) {
                 this.myTokenRegistry.set(token, registration);
                 // Eager-instantiate only if the provided class is container-scoped
                 if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                    this.resolveProviderValue(registration, registration.provider);
+                    this.resolveProviderValue(token, registration);
                 }
             } else {
                 if (existingProvider) {
@@ -661,17 +662,15 @@ function isDisposable(value) {
     }
     resolveRegistration(token, registration, name) {
         let currRegistration = registration;
-        let currProvider = currRegistration.provider;
-        while(isExistingProvider(currProvider)){
-            const targetToken = currProvider.useExisting;
+        while(isExistingProvider(currRegistration.provider)){
+            const targetToken = currRegistration.provider.useExisting;
             currRegistration = this.myTokenRegistry.get(targetToken, name);
             if (!currRegistration) {
                 throwExistingUnregisteredError(token, targetToken);
             }
-            currProvider = currRegistration.provider;
         }
         try {
-            return this.resolveProviderValue(currRegistration, currProvider);
+            return this.resolveProviderValue(token, currRegistration);
         } catch (e) {
             // If we were trying to resolve a token registered via ExistingProvider,
             // we must add the cause of the error to the message
@@ -698,16 +697,16 @@ function isDisposable(value) {
         }
         return undefined;
     }
-    resolveProviderValue(registration, provider) {
-        check(registration.provider === provider, "internal error: mismatching provider");
+    resolveProviderValue(token, registration) {
+        const provider = registration.provider;
         if (isClassProvider(provider)) {
             const Class = provider.useClass;
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return this.resolveScopedValue(registration, (args)=>new Class(...args));
+            return this.resolveScopedValue(token, registration, (args)=>new Class(...args));
         }
         if (isFactoryProvider(provider)) {
             const factory = provider.useFactory;
-            return this.resolveScopedValue(registration, factory);
+            return this.resolveScopedValue(token, registration, factory);
         }
         if (isValueProvider(provider)) {
             return provider.useValue;
@@ -715,7 +714,7 @@ function isDisposable(value) {
         check(!isExistingProvider(provider), "internal error: unexpected ExistingProvider");
         expectNever(provider);
     }
-    resolveScopedValue(registration, factory) {
+    resolveScopedValue(token, registration, factory) {
         let context = useInjectionContext();
         if (!context || context.container !== this) {
             context = {
@@ -728,12 +727,16 @@ function isDisposable(value) {
         const options = registration.options;
         if (resolution.stack.has(provider)) {
             const dependentRef = resolution.dependents.get(provider);
-            check(dependentRef, "circular dependency detected");
+            check(dependentRef, ()=>{
+                const tokenStack = resolution.tokenStack.map((t)=>t.name).concat(token.name).join(" → ");
+                return `circular dependency detected while resolving ${tokenStack}`;
+            });
             return dependentRef.current;
         }
         const scope = this.resolveScope(options?.scope, context);
         const cleanups = [
             provideInjectionContext(context),
+            resolution.tokenStack.push(token) && (()=>resolution.tokenStack.pop()),
             !isBuilder(provider) && resolution.stack.push(provider, {
                 provider,
                 scope