@lppedd/di-wise-neo 0.20.0 → 0.21.1

package/dist/cjs/index.d.ts

@@ -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/cjs/index.js

@@ -57,7 +57,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) {
@@ -104,7 +104,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,
@@ -135,7 +135,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);
@@ -230,7 +230,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: ()=>{
@@ -262,7 +262,7 @@ class Metadata {
         this.tokenRef = {
             // prettier-ignore
             getRefToken: ()=>{
-                check(false, "internal error: unexpected call");
+                check(false, "internal: unexpected getRefToken call");
             },
             getRefTokens: ()=>new Set()
         };
@@ -471,6 +471,7 @@ function isConstructor(token) {
 
 // @internal
 function getTypeName(value) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch(typeof value){
         case "string":
             return `"${value}"`;
@@ -511,7 +512,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;
@@ -544,8 +545,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,
@@ -563,13 +568,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 ?? [];
     }
@@ -661,7 +668,9 @@ function isDisposable(value) {
                 values.add(valueRef.current);
             }
         }
-        return Array.from(values);
+        return [
+            ...values
+        ];
     }
     resetRegistry() {
         this.checkDisposed();
@@ -672,7 +681,9 @@ function isDisposable(value) {
                 values.add(valueRef.current);
             }
         }
-        return Array.from(values);
+        return [
+            ...values
+        ];
     }
     isRegistered(token, name) {
         this.checkDisposed();
@@ -701,7 +712,9 @@ function isDisposable(value) {
                 values.add(valueRef.current);
             }
         }
-        return Array.from(values);
+        return [
+            ...values
+        ];
     }
     resolve(token, name) {
         this.checkDisposed();
@@ -720,20 +733,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();
@@ -750,11 +766,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);
@@ -928,7 +951,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();
@@ -1004,7 +1027,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.
@@ -1023,7 +1046,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){
@@ -1070,6 +1093,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) {