ditox 1.4.1 → 2.2.0

package/docs/classes/{resolvererror.md → ResolverError.md}

@@ -8,25 +8,25 @@ ResolverError is thrown by the resolver when a token is not found in a container
 
 - `Error`
 
-  ↳ **ResolverError**
+  ↳ **`ResolverError`**
 
 ## Table of contents
 
 ### Constructors
 
-- [constructor](resolvererror.md#constructor)
+- [constructor](ResolverError.md#constructor)
 
 ### Properties
 
-- [message](resolvererror.md#message)
-- [name](resolvererror.md#name)
-- [stack](resolvererror.md#stack)
-- [prepareStackTrace](resolvererror.md#preparestacktrace)
-- [stackTraceLimit](resolvererror.md#stacktracelimit)
+- [message](ResolverError.md#message)
+- [name](ResolverError.md#name)
+- [stack](ResolverError.md#stack)
+- [prepareStackTrace](ResolverError.md#preparestacktrace)
+- [stackTraceLimit](ResolverError.md#stacktracelimit)
 
 ### Methods
 
-- [captureStackTrace](resolvererror.md#capturestacktrace)
+- [captureStackTrace](ResolverError.md#capturestacktrace)
 
 ## Constructors
 
@@ -46,7 +46,7 @@ Error.constructor
 
 #### Defined in
 
-[packages/ditox/src/ditox.ts:60](https://github.com/mnasyrov/ditox/blob/153c602/packages/ditox/src/ditox.ts#L60)
+[packages/ditox/src/ditox.ts:61](https://github.com/mnasyrov/ditox/blob/a821171/packages/ditox/src/ditox.ts#L61)
 
 ## Properties
 
@@ -60,7 +60,7 @@ Error.message
 
 #### Defined in
 
-node_modules/typescript/lib/lib.es5.d.ts:974
+node_modules/typescript/lib/lib.es5.d.ts:1023
 
 ___
 
@@ -74,7 +74,7 @@ Error.name
 
 #### Defined in
 
-node_modules/typescript/lib/lib.es5.d.ts:973
+node_modules/typescript/lib/lib.es5.d.ts:1022
 
 ___
 
@@ -88,7 +88,7 @@ Error.stack
 
 #### Defined in
 
-node_modules/typescript/lib/lib.es5.d.ts:975
+node_modules/typescript/lib/lib.es5.d.ts:1024
 
 ___
 
@@ -102,6 +102,8 @@ ___
 
 Optional override for formatting stack traces
 
+**`see`** https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
 ##### Parameters
 
 | Name | Type |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ditox",
-  "version": "1.4.1",
+  "version": "2.2.0",
   "description": "Powerful dependency injection container for building modular apps.",
   "license": "MIT",
   "author": "Mikhail Nasyrov <mikhail@mnasyrov.com> (https://github.com/mnasyrov)",
@@ -22,31 +22,30 @@
   "engines": {
     "node": ">=12"
   },
-  "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.module.js",
-  "jsnext:main": "dist/index.module.js",
-  "unpkg": "dist/index.umd.js",
-  "umd:main": "dist/index.umd.js",
-  "browser": "dist/index.browser.js",
-  "react-native": "dist/index.browser.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "jsnext:main": "dist/esm/index.js",
+  "unpkg": "dist/umd/index.js",
+  "umd:main": "dist/umd/index.js",
+  "browser": "dist/browser/index.js",
+  "react-native": "dist/browser/index.js",
+  "types": "dist/esm/index.d.ts",
   "source": "src/index.ts",
   "sideEffects": false,
   "files": [
     "dist",
     "docs",
-    "lib",
     "src",
     "LICENSE",
-    "mod.ts",
     "README.md"
   ],
   "scripts": {
     "clean": "shx rm -rf dist lib",
-    "test-deno": "deno test test-deno",
-    "build": "rollup -c",
-    "watch": "rollup -c --watch"
+    "test-deno": "npm run build:rollup && deno test test-deno",
+    "build": "npm run build:cjs && npm run build:esm && npm run build:rollup",
+    "build:cjs": "tsc -p tsconfig.build.json --outDir dist/cjs --module commonjs",
+    "build:esm": "tsc -p tsconfig.build.json --outDir dist/esm --module es2015",
+    "build:rollup": "rollup -c"
   },
-  "gitHead": "18463f7db4cc9c261b86324a850c265e7d152091"
+  "gitHead": "f9d1e2d369a00fb12ad62cbb9aa6039104c4cbe3"
 }

package/src/ditox.test.ts

@@ -508,7 +508,16 @@ describe('Container', () => {
 
     it('should throw ResolverError in case a value is not provided', () => {
       const container = createContainer();
-      expect(() => container.resolve(NUMBER)).toThrowError(ResolverError);
+      expect(() => container.resolve(token('test'))).toThrowError(
+        new ResolverError(`Token "test" is not provided`),
+      );
+    });
+
+    it('should throw ResolverError with an empty name in case a token is not resolved', () => {
+      const container = createContainer();
+      expect(() => container.resolve(token())).toThrowError(
+        new ResolverError(`Token "" is not provided`),
+      );
     });
 
     it('should resolve a value from the parent container', () => {

package/src/index.ts

@@ -1,33 +1,33 @@
-export {
+export {token, optional, ResolverError, createContainer} from './ditox';
+export type {
   RequiredToken,
   OptionalToken,
   Token,
-  token,
-  optional,
-  ResolverError,
   FactoryScope,
   FactoryOptions,
   Container,
-  createContainer,
 } from './ditox';
 
 export {
+  isToken,
   bindMultiValue,
-  getValues,
+  tryResolveValue,
+  tryResolveValues,
+  resolveValue,
   resolveValues,
   injectable,
-  getProps,
-  resolveProps,
-  injectableProps,
+  injectableClass,
 } from './utils';
 
 export {
-  Module,
-  ModuleDeclaration,
-  BindModuleOptions,
-  ModuleBindingEntry,
   bindModule,
   bindModules,
   declareModule,
   declareModuleBindings,
 } from './modules';
+export type {
+  Module,
+  ModuleDeclaration,
+  BindModuleOptions,
+  ModuleBindingEntry,
+} from './modules';

package/src/modules.test.ts

@@ -319,5 +319,7 @@ describe('declareModuleBindings()', () => {
     bindModule(container, MODULE_BINDINGS);
     expect(container.get(VALUE1_TOKEN)).toBe(1);
     expect(container.get(VALUE2_TOKEN)).toBe(2);
+
+    expect(container.get(MODULE_BINDINGS.token)).toEqual({});
   });
 });

package/src/modules.ts

@@ -59,13 +59,6 @@ export type ModuleDeclaration<T extends Module<AnyObject>> = {
     [K in keyof GetModuleProps<T>]?: Token<GetModuleProps<T>[K]>;
   };
 
-  /**
-   * Dictionary of module properties which are bound to tokens.
-   *
-   * @deprecated Use `exports` property.
-   */
-  exportedProps?: ModuleDeclaration<T>['exports'];
-
   /** Callback could be used to prepare an environment. It is called before binding the module. */
   beforeBinding?: (container: Container) => void;
 
@@ -109,7 +102,7 @@ export function bindModule<T extends Module<AnyObject>>(
 ): void {
   const {token, imports, factory, beforeBinding, afterBinding} =
     moduleDeclaration;
-  const exports = moduleDeclaration.exports ?? moduleDeclaration.exportedProps;
+  const exports = moduleDeclaration.exports;
 
   const scope = options?.scope;
 

package/src/utils.test.ts

@@ -1,18 +1,18 @@
 import {createContainer, optional, ResolverError, token} from './ditox';
 import {
   bindMultiValue,
-  getProps,
-  getValues,
   injectable,
-  injectableProps,
-  resolveProps,
+  injectableClass,
+  resolveValue,
   resolveValues,
+  tryResolveValue,
+  tryResolveValues,
 } from './utils';
 
 const NUMBER = token<number>('number');
 const STRING = token<string>('string');
 
-describe('bindMultiValue', () => {
+describe('bindMultiValue()', () => {
   const NUMBERS = token<Array<number>>('numbers');
 
   it('should append a value to an array declared by a token', () => {
@@ -53,13 +53,53 @@ describe('bindMultiValue', () => {
   });
 });
 
-describe('getValues', () => {
+describe('tryResolveValue()', () => {
+  it('should return an object with values by the tokens', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+    container.bindValue(STRING, 'abc');
+
+    const props: {a: number; b: string} = tryResolveValue(container, {
+      a: NUMBER,
+      b: STRING,
+    });
+    expect(props).toEqual({a: 1, b: 'abc'});
+  });
+
+  it('should return "undefined" item in case a value is not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const props = tryResolveValue(container, {a: NUMBER, b: STRING});
+    expect(props).toEqual({a: 1, b: undefined});
+  });
+
+  it('should return values of optional tokens in case they are not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const OPTIONAL_STRING = optional(STRING, 'value');
+
+    const props = tryResolveValue(container, {
+      a: NUMBER,
+      b: STRING,
+      c: OPTIONAL_STRING,
+    });
+    expect(props).toEqual({a: 1, b: undefined, c: 'value'});
+  });
+});
+
+describe('tryResolveValues()', () => {
   it('should return values for the tokens', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, 'abc');
 
-    const values: [number, string] = getValues(container, NUMBER, STRING);
+    const values: [number, string] = tryResolveValues(
+      container,
+      NUMBER,
+      STRING,
+    );
     expect(values).toEqual([1, 'abc']);
   });
 
@@ -67,7 +107,7 @@ describe('getValues', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const values = getValues(container, NUMBER, STRING);
+    const values = tryResolveValues(container, NUMBER, STRING);
     expect(values).toEqual([1, undefined]);
   });
 
@@ -77,7 +117,7 @@ describe('getValues', () => {
 
     const OPTIONAL_STRING = optional(STRING, 'value');
 
-    const values = getValues(container, NUMBER, STRING, OPTIONAL_STRING);
+    const values = tryResolveValues(container, NUMBER, STRING, OPTIONAL_STRING);
     expect(values).toEqual([1, undefined, 'value']);
   });
 
@@ -85,7 +125,7 @@ describe('getValues', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const values = getValues(
+    const values = tryResolveValues(
       container,
       NUMBER,
       NUMBER,
@@ -102,7 +142,43 @@ describe('getValues', () => {
   });
 });
 
-describe('resolveValues', () => {
+describe('resolveValue()', () => {
+  it('should an object with resolved values from the container for the specified token props', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+    container.bindValue(STRING, 'abc');
+
+    const props: {a: number; b: string} = resolveValue(container, {
+      a: NUMBER,
+      b: STRING,
+    });
+    expect(props).toEqual({a: 1, b: 'abc'});
+  });
+
+  it('should throw an error in case a value is not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    expect(() => {
+      resolveValue(container, {a: NUMBER, b: STRING});
+    }).toThrowError(
+      new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
+    );
+  });
+
+  it('should resolve values of optional tokens in case they are not provided', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const props = resolveValue(container, {
+      a: NUMBER,
+      b: optional(STRING, 'value'),
+    });
+    expect(props).toEqual({a: 1, b: 'value'});
+  });
+});
+
+describe('resolveValues()', () => {
   it('should resolve tokens from the container', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
@@ -127,12 +203,30 @@ describe('resolveValues', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const values = getValues(container, NUMBER, optional(STRING, 'value'));
+    const values = resolveValues(container, NUMBER, optional(STRING, 'value'));
     expect(values).toEqual([1, 'value']);
   });
+
+  it('should resolve a dictionary of tokens', () => {
+    const container = createContainer();
+    container.bindValue(NUMBER, 1);
+
+    const values = resolveValue(container, {
+      a: NUMBER,
+      b: optional(STRING, 'value'),
+    });
+    expect(values).toEqual({
+      a: 1,
+      b: 'value',
+    });
+  });
 });
 
 describe('injectable()', () => {
+  function join({a, b}: {a: number; b: string}): string {
+    return `${a}/${b}`;
+  }
+
   it('should inject values from Container as arguments of the factory', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
@@ -174,83 +268,104 @@ describe('injectable()', () => {
 
     expect(decoratedFactory(container)).toBe('1value');
   });
-});
 
-describe('getProps', () => {
-  it('should return an object with values by the tokens', () => {
+  it('should inject values from Container as an object for the first argument of the factory', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
-    container.bindValue(STRING, 'abc');
+    container.bindValue(STRING, '2');
 
-    const props: {a?: number; b?: string} = getProps(container, {
-      a: NUMBER,
-      b: STRING,
-    });
-    expect(props).toEqual({a: 1, b: 'abc'});
+    const decoratedFactory = injectable(join, {a: NUMBER, b: STRING});
+
+    expect(decoratedFactory(container)).toBe('1/2');
   });
 
-  it('should return "undefined" item in case a value is not provided', () => {
+  it('should throw ResolverError error in case a value is not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const props = getProps(container, {a: NUMBER, b: STRING});
-    expect(props).toEqual({a: 1, b: undefined});
+    const decoratedFactory = injectable(join, {a: NUMBER, b: STRING});
+
+    expect(() => decoratedFactory(container)).toThrowError(
+      new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
+    );
   });
 
-  it('should return values of optional tokens in case they are not provided', () => {
+  it('should inject values of optional tokens in case values are not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const OPTIONAL_STRING = optional(STRING, 'value');
-
-    const props = getProps(container, {
+    const decoratedFactory = injectable(join, {
       a: NUMBER,
-      b: STRING,
-      c: OPTIONAL_STRING,
+      b: optional(STRING, 'value'),
     });
-    expect(props).toEqual({a: 1, b: undefined, c: 'value'});
+
+    expect(decoratedFactory(container)).toBe('1/value');
   });
 });
 
-describe('resolveProps', () => {
-  it('should an object with resolved values from the container for the specified token props', () => {
+describe('injectableClass()', () => {
+  class TestClass {
+    a: number;
+    b: string;
+
+    constructor(a: number, b: string) {
+      this.a = a;
+      this.b = b;
+    }
+
+    concat(): string {
+      return this.a + this.b;
+    }
+  }
+
+  it('should inject values from Container as arguments of the constructor', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
-    container.bindValue(STRING, 'abc');
+    container.bindValue(STRING, '2');
 
-    const props: {a: number; b: string} = resolveProps(container, {
-      a: NUMBER,
-      b: STRING,
-    });
-    expect(props).toEqual({a: 1, b: 'abc'});
+    const factory = injectableClass(TestClass, NUMBER, STRING);
+
+    expect(factory(container).concat()).toBe('12');
   });
 
-  it('should throw an error in case a value is not provided', () => {
+  it('should throw ResolverError error in case a value is not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    expect(() => {
-      resolveProps(container, {a: NUMBER, b: STRING});
-    }).toThrowError(
+    const factory = injectableClass(TestClass, NUMBER, STRING);
+
+    expect(() => factory(container)).toThrowError(
       new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
     );
   });
 
-  it('should resolve values of optional tokens in case they are not provided', () => {
+  it('should inject values of optional tokens in case values are not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const props = resolveProps(container, {
-      a: NUMBER,
-      b: optional(STRING, 'value'),
-    });
-    expect(props).toEqual({a: 1, b: 'value'});
+    const factory = injectableClass(
+      TestClass,
+      NUMBER,
+      optional(STRING, 'value'),
+    );
+
+    expect(factory(container).concat()).toBe('1value');
   });
 });
 
-describe('injectableProps()', () => {
-  function join({a, b}: {a: number; b: string}): string {
-    return `${a}/${b}`;
+describe('injectableClass()', () => {
+  class TestClass {
+    a: number;
+    b: string;
+
+    constructor(props: {a: number; b: string}) {
+      this.a = props.a;
+      this.b = props.b;
+    }
+
+    join(): string {
+      return `${this.a}/${this.b}`;
+    }
   }
 
   it('should inject values from Container as an object for the first argument of the factory', () => {
@@ -258,18 +373,18 @@ describe('injectableProps()', () => {
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, '2');
 
-    const decoratedFactory = injectableProps(join, {a: NUMBER, b: STRING});
+    const factory = injectableClass(TestClass, {a: NUMBER, b: STRING});
 
-    expect(decoratedFactory(container)).toBe('1/2');
+    expect(factory(container).join()).toBe('1/2');
   });
 
   it('should throw ResolverError error in case a value is not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const decoratedFactory = injectableProps(join, {a: NUMBER, b: STRING});
+    const factory = injectableClass(TestClass, {a: NUMBER, b: STRING});
 
-    expect(() => decoratedFactory(container)).toThrowError(
+    expect(() => factory(container)).toThrowError(
       new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
     );
   });
@@ -278,11 +393,11 @@ describe('injectableProps()', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const decoratedFactory = injectableProps(join, {
+    const factory = injectableClass(TestClass, {
       a: NUMBER,
       b: optional(STRING, 'value'),
     });
 
-    expect(decoratedFactory(container)).toBe('1/value');
+    expect(factory(container).join()).toBe('1/value');
   });
 });