ditox 3.2.0 → 3.3.1

package/src/container.test.ts

@@ -1,11 +1,14 @@
+import { describe, expect, it, test, vi } from 'vitest';
 import {
   CONTAINER,
   createContainer,
+  FACTORIES_MAP,
   PARENT_CONTAINERS,
+  RESOLVER,
   ResolverError,
 } from './container';
-import {optional, token} from './tokens';
-import {injectable} from './utils';
+import { optional, token } from './tokens';
+import { injectable } from './utils';
 
 const NUMBER = token<number>('number');
 const STRING = token<string>('string');
@@ -28,7 +31,7 @@ describe('Container', () => {
     it('should bind a result of a factory and prevent invoking it', () => {
       const container = createContainer();
 
-      const factory = jest.fn(() => 1);
+      const factory = vi.fn(() => 1);
       container.bindFactory(NUMBER, factory);
       container.bindValue(NUMBER, 2);
 
@@ -54,7 +57,7 @@ describe('Container', () => {
       const container = createContainer();
 
       let containerArg;
-      const factory = jest.fn((arg) => {
+      const factory = vi.fn((arg) => {
         containerArg = arg;
         return 1;
       });
@@ -68,8 +71,8 @@ describe('Container', () => {
     it('should rebind a factory in case it was bound', () => {
       const container = createContainer();
 
-      const factory1 = jest.fn(() => 1);
-      const factory2 = jest.fn(() => 2);
+      const factory1 = vi.fn(() => 1);
+      const factory2 = vi.fn(() => 2);
       container.bindFactory(NUMBER, factory1);
       container.bindFactory(NUMBER, factory2);
 
@@ -87,7 +90,7 @@ describe('Container', () => {
       container.bindValue(START, 20);
 
       let counter = 0;
-      const factory = jest.fn((start) => start + ++counter);
+      const factory = vi.fn((start) => start + ++counter);
       parent.bindFactory(NUMBER, injectable(factory, START), {
         scope: 'singleton',
       });
@@ -113,7 +116,7 @@ describe('Container', () => {
       container.bindValue(START, 20);
 
       let counter = 0;
-      const factory = jest.fn((start) => start + ++counter);
+      const factory = vi.fn((start) => start + ++counter);
       parent.bindFactory(NUMBER, injectable(factory, START), {
         scope: 'scoped',
       });
@@ -129,7 +132,7 @@ describe('Container', () => {
     it('should inherit a factory with "scoped" scope', async () => {
       const parentParent = createContainer();
       let counter = 0;
-      const factory = jest.fn(() => ++counter);
+      const factory = vi.fn(() => ++counter);
 
       parentParent.bindFactory(NUMBER, factory);
 
@@ -163,7 +166,7 @@ describe('Container', () => {
       container.bindValue(START, 20);
 
       let counter = 0;
-      const factory = jest.fn((start) => start + ++counter);
+      const factory = vi.fn((start) => start + ++counter);
       parent.bindFactory(NUMBER, injectable(factory, START));
 
       expect(container.get(NUMBER)).toBe(11);
@@ -190,7 +193,7 @@ describe('Container', () => {
       container3.bindValue(START, 30);
 
       let counter = 0;
-      const factory = jest.fn((start) => start + ++counter);
+      const factory = vi.fn((start) => start + ++counter);
       parent.bindFactory(NUMBER, injectable(factory, START), {
         scope: 'scoped',
       });
@@ -235,7 +238,7 @@ describe('Container', () => {
       container.bindValue(START, 20);
 
       let counter = 0;
-      const factory = jest.fn((start) => start + ++counter);
+      const factory = vi.fn((start) => start + ++counter);
       parent.bindFactory(NUMBER, injectable(factory, START), {
         scope: 'transient',
       });
@@ -251,9 +254,9 @@ describe('Container', () => {
     it('should bind a factory with "onRemoved" callback', () => {
       const container = createContainer();
 
-      const factory = jest.fn(() => 1);
-      const callback = jest.fn();
-      container.bindFactory(NUMBER, factory, {onRemoved: callback});
+      const factory = vi.fn(() => 1);
+      const callback = vi.fn();
+      container.bindFactory(NUMBER, factory, { onRemoved: callback });
 
       expect(container.get(NUMBER)).toBe(1);
       container.remove(NUMBER);
@@ -284,9 +287,9 @@ describe('Container', () => {
     it('should remove "singleton" factory silently in case its value has never been resolved', () => {
       const container = createContainer();
 
-      const factory = jest.fn(() => 1);
-      const onRemoved = jest.fn();
-      container.bindFactory(NUMBER, factory, {scope: 'singleton', onRemoved});
+      const factory = vi.fn(() => 1);
+      const onRemoved = vi.fn();
+      container.bindFactory(NUMBER, factory, { scope: 'singleton', onRemoved });
       container.remove(NUMBER);
 
       expect(container.get(NUMBER)).toBeUndefined();
@@ -297,9 +300,9 @@ describe('Container', () => {
     it('should remove "singleton" factory with calling "onRemoved" in case its value has been resolved', () => {
       const container = createContainer();
 
-      const factory = jest.fn(() => 100);
-      const onRemoved = jest.fn();
-      container.bindFactory(NUMBER, factory, {scope: 'singleton', onRemoved});
+      const factory = vi.fn(() => 100);
+      const onRemoved = vi.fn();
+      container.bindFactory(NUMBER, factory, { scope: 'singleton', onRemoved });
 
       expect(container.get(NUMBER)).toBe(100);
       container.remove(NUMBER);
@@ -315,9 +318,9 @@ describe('Container', () => {
       const container = createContainer(parent);
 
       let count = 1;
-      const factory = jest.fn(() => count++);
-      const onRemoved = jest.fn();
-      parent.bindFactory(NUMBER, factory, {scope: 'scoped', onRemoved});
+      const factory = vi.fn(() => count++);
+      const onRemoved = vi.fn();
+      parent.bindFactory(NUMBER, factory, { scope: 'scoped', onRemoved });
 
       expect(parent.get(NUMBER)).toBe(1);
       expect(container.get(NUMBER)).toBe(1);
@@ -332,8 +335,8 @@ describe('Container', () => {
     it('should remove "transient" factory in case its value has never been resolved', () => {
       const container = createContainer();
 
-      const factory = jest.fn(() => 1);
-      container.bindFactory(NUMBER, factory, {scope: 'transient'});
+      const factory = vi.fn(() => 1);
+      container.bindFactory(NUMBER, factory, { scope: 'transient' });
       container.remove(NUMBER);
 
       expect(container.get(NUMBER)).toBeUndefined();
@@ -343,8 +346,8 @@ describe('Container', () => {
     it('should remove "transient" factory in case its value has been resolved', () => {
       const container = createContainer();
 
-      const factory = jest.fn(() => 1);
-      container.bindFactory(NUMBER, factory, {scope: 'transient'});
+      const factory = vi.fn(() => 1);
+      container.bindFactory(NUMBER, factory, { scope: 'transient' });
       expect(container.get(NUMBER)).toBe(1);
 
       container.remove(NUMBER);
@@ -365,6 +368,32 @@ describe('Container', () => {
   });
 
   describe('removeAll()', () => {
+    it('should restore internal tokens after a callback throws and allow reuse', () => {
+      const parent = createContainer();
+      const container = createContainer(parent);
+      const child = createContainer(container);
+      parent.bindValue(STRING, 'parent');
+      container.bindFactory(NUMBER, () => 1, {
+        onRemoved() {
+          throw new Error('cleanup failed');
+        },
+      });
+      container.resolve(NUMBER);
+
+      expect(() => container.removeAll()).toThrow('cleanup failed');
+      expect(container.resolve(CONTAINER)).toBe(container);
+      expect(container.resolve(PARENT_CONTAINERS)).toEqual([parent]);
+      expect(container.resolve(RESOLVER)).toBeTypeOf('function');
+      expect(container.hasToken(FACTORIES_MAP)).toBe(true);
+      expect(child.resolve(STRING)).toBe('parent');
+      const onRemoved = vi.fn();
+      container.bindFactory(NUMBER, () => 2, { onRemoved });
+      expect(child.resolve(NUMBER)).toBe(2);
+      container.removeAll();
+      expect(onRemoved).toHaveBeenCalledExactlyOnceWith(2);
+      expect(child.get(NUMBER)).toBeUndefined();
+    });
+
     it('should remove all values and factories', () => {
       const container = createContainer();
 
@@ -382,8 +411,8 @@ describe('Container', () => {
       const F1 = token('f1');
       const F2 = token('f2');
 
-      const unbind1 = jest.fn();
-      const unbind2 = jest.fn();
+      const unbind1 = vi.fn();
+      const unbind2 = vi.fn();
 
       const container = createContainer();
       container.bindFactory(F1, () => 10, {
@@ -419,7 +448,7 @@ describe('Container', () => {
 
   describe('hasToken()', () => {
     it('should check if a container hierarchy has the token', () => {
-      const factory = jest.fn();
+      const factory = vi.fn();
 
       const token1 = token();
       const token2 = token();
@@ -621,8 +650,8 @@ describe('Container', () => {
 
     it('should resolve a value by shared tokens', () => {
       const key = 'token-' + Date.now();
-      const t1 = token({key});
-      const t2 = token({key});
+      const t1 = token({ key });
+      const t2 = token({ key });
       expect(t1).not.toBe(t2);
 
       const container = createContainer();
@@ -687,5 +716,20 @@ describe('Container', () => {
 
       expect(() => child.resolve(NUMBER)).toThrow(ResolverError);
     });
+
+    it('should NOT resolve a token from a parent that does NOT provide a RESOLVER token', () => {
+      const T1 = token<number>('T1');
+
+      const customParent = {
+        hasToken: () => true,
+        get: (t: any) => (t === RESOLVER ? undefined : undefined),
+        resolve: () => {
+          throw new Error('Not implemented');
+        },
+      };
+
+      const container = createContainer(customParent);
+      expect(container.get(T1)).toBeUndefined();
+    });
   });
 });

package/src/container.ts

@@ -1,4 +1,4 @@
-import {Token, token} from './tokens';
+import { Token, token } from './tokens';
 
 /**
  * ResolverError is thrown by the resolver when a token is not found in a container.
@@ -75,6 +75,8 @@ export type Container = {
 
   /**
    * Removes all bindings in the container.
+   * Continues after cleanup failures and rethrows the first thrown value unchanged
+   * after clearing bindings and restoring internal tokens. Later failures are discarded.
    */
   removeAll(): void;
 };
@@ -178,7 +180,7 @@ export function createContainer(
         return;
       }
 
-      factories.set(token.symbol, {factory, options});
+      factories.set(token.symbol, { factory, options });
     },
 
     remove<T>(token: Token<T>): void {
@@ -196,15 +198,28 @@ export function createContainer(
     },
 
     removeAll(): void {
-      factories.forEach((context, tokenSymbol) => {
-        if (context.options) {
-          executeOnRemoved(tokenSymbol, context.options);
-        }
-      });
-
-      values.clear();
-      factories.clear();
-      bindInternalTokens();
+      // A separate flag preserves thrown values such as undefined or false.
+      let hasError = false;
+      let firstError: unknown;
+      try {
+        factories.forEach((context, tokenSymbol) => {
+          try {
+            if (context.options) {
+              executeOnRemoved(tokenSymbol, context.options);
+            }
+          } catch (error) {
+            if (!hasError) {
+              hasError = true;
+              firstError = error;
+            }
+          }
+        });
+      } finally {
+        values.clear();
+        factories.clear();
+        bindInternalTokens();
+      }
+      if (hasError) throw firstError;
     },
 
     hasToken(token: Token<unknown>): boolean {

package/src/index.ts

@@ -1,34 +1,32 @@
-export {token, optional} from './tokens';
-export type {RequiredToken, OptionalToken, Token} from './tokens';
-
-export {ResolverError, createContainer} from './container';
 export type {
-  FactoryScope,
-  FactoryOptions,
   Container,
   ContainerResolver,
+  FactoryOptions,
+  FactoryScope,
 } from './container';
-
-export {
-  isToken,
-  bindMultiValue,
-  tryResolveValue,
-  tryResolveValues,
-  resolveValue,
-  resolveValues,
-  injectable,
-  injectableClass,
-} from './utils';
-
+export { createContainer, ResolverError } from './container';
+export type {
+  AnyModuleDeclaration,
+  BindModuleOptions,
+  Module,
+  ModuleBindingEntry,
+  ModuleDeclaration,
+} from './modules';
 export {
   bindModule,
   bindModules,
   declareModule,
   declareModuleBindings,
 } from './modules';
-export type {
-  Module,
-  ModuleDeclaration,
-  BindModuleOptions,
-  ModuleBindingEntry,
-} from './modules';
+export type { OptionalToken, RequiredToken, Token } from './tokens';
+export { optional, token } from './tokens';
+export {
+  bindMultiValue,
+  injectable,
+  injectableClass,
+  isToken,
+  resolveValue,
+  resolveValues,
+  tryResolveValue,
+  tryResolveValues,
+} from './utils';