@lppedd/di-wise-neo 0.20.0 → 0.21.1

package/dist/es/index.d.mts

@@ -627,11 +627,13 @@ interface Container {
      * Disposes this container and all its cached values.
      *
      * Token values implementing a `Disposable` interface (e.g., objects with a `dispose()` function)
-     * are automatically disposed during this process.
+     * are also disposed. All disposals, whether synchronous or asynchronous, are returned as promises
+     * in an array. Callers may await these promises (e.g., using `Promise.allSettled()`) if they want
+     * to ensure that all async work has completed.
      *
      * Note that children containers are disposed first, in creation order.
      */
-    dispose(): void;
+    dispose(): Promise<unknown>[];
 }
 /**
  * Creates a new container.

package/dist/es/index.mjs

@@ -55,7 +55,7 @@ function getTokenName(token) {
 }
 function getFullTokenName([token, name]) {
     const tokenName = token ? token.name || "<unnamed>" : "<undefined token>";
-    return name ? `${tokenName}["${name}"]` : tokenName;
+    return name !== undefined ? `${tokenName}["${name}"]` : tokenName;
 }
 function getCause(error) {
     if (!error) {
@@ -102,7 +102,7 @@ class KeyedStack {
         return this.myEntries.at(-1)?.value;
     }
     push(key, value) {
-        check(!this.has(key), "invariant violation");
+        check(!this.has(key), "internal: invariant violation");
         this.myKeys.add(key);
         this.myEntries.push({
             key,
@@ -133,7 +133,7 @@ class WeakRefMap {
         return undefined;
     }
     set(key, value) {
-        check(!this.get(key), "invariant violation");
+        check(!this.get(key), "internal: invariant violation");
         this.myMap.set(key, new WeakRef(value));
         return ()=>{
             this.myMap.delete(key);
@@ -228,7 +228,7 @@ function tokenRef(token) {
     return {
         getRefToken: ()=>{
             const tokenOrTokens = token();
-            check(!Array.isArray(tokenOrTokens), "internal error: single token expected");
+            check(!Array.isArray(tokenOrTokens), "internal: unexpected array of tokens");
             return tokenOrTokens;
         },
         getRefTokens: ()=>{
@@ -260,7 +260,7 @@ class Metadata {
         this.tokenRef = {
             // prettier-ignore
             getRefToken: ()=>{
-                check(false, "internal error: unexpected call");
+                check(false, "internal: unexpected getRefToken call");
             },
             getRefTokens: ()=>new Set()
         };
@@ -469,6 +469,7 @@ function isConstructor(token) {
 
 // @internal
 function getTypeName(value) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch(typeof value){
         case "string":
             return `"${value}"`;
@@ -509,7 +510,7 @@ class TokenRegistry {
         ] || this.getAllFromParent(token, name);
     }
     put(token, registration) {
-        check(!internals.has(token), `cannot register reserved token ${token.name}`);
+        check(!internals.has(token), `internal: cannot register reserved token ${token.name}`);
         let registrations = this.myRegistrations.get(token);
         if (registrations) {
             const name = registration.name;
@@ -542,8 +543,12 @@ class TokenRegistry {
         return registrations;
     }
     deleteAll() {
-        const tokens = Array.from(this.myRegistrations.keys());
-        const registrations = Array.from(this.myRegistrations.values()).flat();
+        const tokens = [
+            ...this.myRegistrations.keys()
+        ];
+        const registrations = [
+            ...this.myRegistrations.values()
+        ].flat();
         this.myRegistrations.clear();
         return [
             tokens,
@@ -561,13 +566,15 @@ class TokenRegistry {
                 registration.valueRef = undefined;
             }
         }
-        return Array.from(values);
+        return [
+            ...values
+        ];
     }
     getAllFromParent(token, name) {
         let registrations = this.myRegistrations.get(token) || this.myParent?.getAllFromParent(token, name);
         if (registrations && name !== undefined) {
             registrations = registrations.filter((r)=>r.name === name);
-            check(registrations.length < 2, `internal error: more than one registration named '${name}'`);
+            check(registrations.length < 2, `internal: multiple registrations with name '${name}'`);
         }
         return registrations ?? [];
     }
@@ -659,7 +666,9 @@ function isDisposable(value) {
                 values.add(valueRef.current);
             }
         }
-        return Array.from(values);
+        return [
+            ...values
+        ];
     }
     resetRegistry() {
         this.checkDisposed();
@@ -670,7 +679,9 @@ function isDisposable(value) {
                 values.add(valueRef.current);
             }
         }
-        return Array.from(values);
+        return [
+            ...values
+        ];
     }
     isRegistered(token, name) {
         this.checkDisposed();
@@ -699,7 +710,9 @@ function isDisposable(value) {
                 values.add(valueRef.current);
             }
         }
-        return Array.from(values);
+        return [
+            ...values
+        ];
     }
     resolve(token, name) {
         this.checkDisposed();
@@ -718,20 +731,23 @@ function isDisposable(value) {
         return this.resolveAllToken(token, true);
     }
     addHook(hook) {
+        this.checkDisposed();
         this.myHookRegistry.add(hook);
     }
     removeHook(hook) {
+        this.checkDisposed();
         this.myHookRegistry.delete(hook);
     }
     dispose() {
         if (this.myDisposed) {
-            return;
+            return [];
         }
+        this.myDisposed = true;
+        const promises = [];
         // Dispose children containers first
         for (const child of this.myChildren){
-            child.dispose();
+            promises.push(...child.dispose());
         }
-        this.myDisposed = true;
         this.myChildren.clear();
         this.myParent?.myChildren?.delete(this);
         const [, registrations] = this.myTokenRegistry.deleteAll();
@@ -748,11 +764,18 @@ function isDisposable(value) {
         }
         for (const value of allValues){
             if (isDisposable(value)) {
-                value.dispose();
+                try {
+                    promises.push(Promise.resolve(value.dispose()));
+                } catch (e) {
+                    promises.push(Promise.reject(e));
+                }
             }
         }
-        this.notifyDisposeHooks(Array.from(cacheValues));
+        this.notifyDisposeHooks([
+            ...cacheValues
+        ]);
         this.myHookRegistry.clear();
+        return promises;
     }
     registerClass(Class) {
         const metadata = getMetadata(Class);
@@ -926,7 +949,7 @@ function isDisposable(value) {
         if (isValueProvider(provider)) {
             return provider.useValue;
         }
-        check(false, "internal error: unexpected ExistingProvider");
+        check(false, "internal: unexpected ExistingProvider");
     }
     resolveScopedValue(token, registration, factory) {
         let context = useInjectionContext();
@@ -1002,7 +1025,7 @@ function isDisposable(value) {
     resolveCtorDependencies(registration) {
         const dependencies = registration.dependencies;
         if (dependencies) {
-            check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            check(isClassProvider(registration.provider), `internal: expected a ClassProvider`);
             const ctorDeps = dependencies.ctor.filter((d)=>d.appliedBy);
             if (ctorDeps.length > 0) {
                 // Let's check if all necessary constructor parameters are decorated.
@@ -1021,7 +1044,7 @@ function isDisposable(value) {
     injectMethodDependencies(registration, instance) {
         const dependencies = registration.dependencies;
         if (dependencies) {
-            check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            check(isClassProvider(registration.provider), `internal: expected a ClassProvider`);
             const ctor = registration.provider.useClass;
             // Perform method injection
             for (const entry of dependencies.methods){
@@ -1068,6 +1091,8 @@ function isDisposable(value) {
                 return instance ? optionalBy(instance, token, name) : this.tryResolve(token, name);
             case "OptionalAll":
                 return instance ? optionalAll(token) : this.tryResolveAll(token);
+            case undefined:
+                check(false, "internal: unexpected undefined appliedBy");
         }
     }
     notifyProvideHooks(value, scope) {