ditox 1.4.1 → 2.2.0

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareModuleBindings = exports.declareModule = exports.bindModules = exports.bindModule = exports.injectableClass = exports.injectable = exports.resolveValues = exports.resolveValue = exports.tryResolveValues = exports.tryResolveValue = exports.bindMultiValue = exports.isToken = exports.createContainer = exports.ResolverError = exports.optional = exports.token = void 0;
+var ditox_1 = require("./ditox");
+Object.defineProperty(exports, "token", { enumerable: true, get: function () { return ditox_1.token; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return ditox_1.optional; } });
+Object.defineProperty(exports, "ResolverError", { enumerable: true, get: function () { return ditox_1.ResolverError; } });
+Object.defineProperty(exports, "createContainer", { enumerable: true, get: function () { return ditox_1.createContainer; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "isToken", { enumerable: true, get: function () { return utils_1.isToken; } });
+Object.defineProperty(exports, "bindMultiValue", { enumerable: true, get: function () { return utils_1.bindMultiValue; } });
+Object.defineProperty(exports, "tryResolveValue", { enumerable: true, get: function () { return utils_1.tryResolveValue; } });
+Object.defineProperty(exports, "tryResolveValues", { enumerable: true, get: function () { return utils_1.tryResolveValues; } });
+Object.defineProperty(exports, "resolveValue", { enumerable: true, get: function () { return utils_1.resolveValue; } });
+Object.defineProperty(exports, "resolveValues", { enumerable: true, get: function () { return utils_1.resolveValues; } });
+Object.defineProperty(exports, "injectable", { enumerable: true, get: function () { return utils_1.injectable; } });
+Object.defineProperty(exports, "injectableClass", { enumerable: true, get: function () { return utils_1.injectableClass; } });
+var modules_1 = require("./modules");
+Object.defineProperty(exports, "bindModule", { enumerable: true, get: function () { return modules_1.bindModule; } });
+Object.defineProperty(exports, "bindModules", { enumerable: true, get: function () { return modules_1.bindModules; } });
+Object.defineProperty(exports, "declareModule", { enumerable: true, get: function () { return modules_1.declareModule; } });
+Object.defineProperty(exports, "declareModuleBindings", { enumerable: true, get: function () { return modules_1.declareModuleBindings; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,iCAAwE;AAAhE,8FAAA,KAAK,OAAA;AAAE,iGAAA,QAAQ,OAAA;AAAE,sGAAA,aAAa,OAAA;AAAE,wGAAA,eAAe,OAAA;AAUvD,iCASiB;AARf,gGAAA,OAAO,OAAA;AACP,uGAAA,cAAc,OAAA;AACd,wGAAA,eAAe,OAAA;AACf,yGAAA,gBAAgB,OAAA;AAChB,qGAAA,YAAY,OAAA;AACZ,sGAAA,aAAa,OAAA;AACb,mGAAA,UAAU,OAAA;AACV,wGAAA,eAAe,OAAA;AAGjB,qCAKmB;AAJjB,qGAAA,UAAU,OAAA;AACV,sGAAA,WAAW,OAAA;AACX,wGAAA,aAAa,OAAA;AACb,gHAAA,qBAAqB,OAAA"}

package/dist/cjs/modules.d.ts

@@ -0,0 +1,118 @@
+import { Container, Token } from './ditox';
+declare type AnyObject = Record<string, any>;
+declare type EmptyObject = Record<string, never>;
+declare type ModuleController = {
+    /** Dispose the module and clean its resources */
+    destroy?: () => void;
+};
+/**
+ * Dependency module
+ *
+ * @example
+ * ```ts
+ * type LoggerModule = Module<{
+ *   logger: Logger;
+ * }>;
+ * ```
+ */
+export declare type Module<ModuleProps extends AnyObject = EmptyObject> = ModuleController & ModuleProps;
+declare type GetModuleProps<T> = T extends Module<infer Props> ? Props : never;
+/**
+ * Description how to bind the module in declarative way.
+ *
+ * @example
+ * ```ts
+ * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {
+ *   token: LOGGER_MODULE_TOKEN,
+ *   factory: (container) => {
+ *     const transport = container.resolve(TRANSPORT_TOKEN).open();
+ *     return {
+ *       logger: { log: (message) => transport.write(message) },
+ *       destroy: () => transport.close(),
+ *     }
+ *   },
+ *   exports: {
+ *     logger: LOGGER_TOKEN,
+ *   },
+ * };
+ * ```
+ */
+export declare type ModuleDeclaration<T extends Module<AnyObject>> = {
+    /** Token for the module */
+    token: Token<T>;
+    /** Modules for binding  */
+    imports?: ReadonlyArray<ModuleBindingEntry>;
+    /** Factory of the module */
+    factory: (container: Container) => T;
+    /** Dictionary of module properties which are bound to tokens. */
+    exports?: {
+        [K in keyof GetModuleProps<T>]?: Token<GetModuleProps<T>[K]>;
+    };
+    /** Callback could be used to prepare an environment. It is called before binding the module. */
+    beforeBinding?: (container: Container) => void;
+    /** Callback could be used to export complex dependencies from the module. It is called after binding the module.  */
+    afterBinding?: (container: Container) => void;
+};
+/**
+ * Options for module binding.
+ *
+ * `scope` types:
+ *   - `singleton` - **This is the default**. The module is created and cached by the container which registered the factory.
+ *   - `scoped` - The module is created and cached by the container which starts resolving.
+ */
+export declare type BindModuleOptions = {
+    scope?: 'scoped' | 'singleton';
+};
+export declare type ModuleBindingEntry = ModuleDeclaration<AnyObject> | {
+    module: ModuleDeclaration<AnyObject>;
+    options: BindModuleOptions;
+};
+/**
+ * Binds the dependency module to the container
+ * @param container - Dependency container.
+ * @param moduleDeclaration - Declaration of the dependency module.
+ * @param options - Options for module binding.
+ *
+ * @example
+ * ```ts
+ * bindModule(container, LOGGER_MODULE);
+ * ```
+ */
+export declare function bindModule<T extends Module<AnyObject>>(container: Container, moduleDeclaration: ModuleDeclaration<T>, options?: BindModuleOptions): void;
+/**
+ * Binds dependency modules to the container
+ *
+ * @param container - Dependency container for binding
+ * @param modules - Array of module binding entries: module declaration or `{module: ModuleDeclaration, options: BindModuleOptions}` objects.
+ */
+export declare function bindModules(container: Container, modules: ReadonlyArray<ModuleBindingEntry>): void;
+/**
+ * Declares a module binding
+ *
+ * @param declaration - a module declaration
+ * @param declaration.token - optional field
+ *
+ *  @example
+ * ```ts
+ * const LOGGER_MODULE = declareModule<LoggerModule>({
+ *   factory: (container) => {
+ *     const transport = container.resolve(TRANSPORT_TOKEN).open();
+ *     return {
+ *       logger: { log: (message) => transport.write(message) },
+ *       destroy: () => transport.close(),
+ *     }
+ *   },
+ *   exports: {
+ *     logger: LOGGER_TOKEN,
+ *   },
+ * });
+ * ```
+ */
+export declare function declareModule<T>(declaration: Omit<ModuleDeclaration<T>, 'token'> & Partial<Pick<ModuleDeclaration<T>, 'token'>>): ModuleDeclaration<T>;
+/**
+ * Declares bindings of several modules
+ *
+ * @param modules - module declaration entries
+ */
+export declare function declareModuleBindings(modules: ReadonlyArray<ModuleBindingEntry>): ModuleDeclaration<Module>;
+export {};

package/dist/cjs/modules.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareModuleBindings = exports.declareModule = exports.bindModules = exports.bindModule = void 0;
+const ditox_1 = require("./ditox");
+const utils_1 = require("./utils");
+/**
+ * Binds the dependency module to the container
+ * @param container - Dependency container.
+ * @param moduleDeclaration - Declaration of the dependency module.
+ * @param options - Options for module binding.
+ *
+ * @example
+ * ```ts
+ * bindModule(container, LOGGER_MODULE);
+ * ```
+ */
+function bindModule(container, moduleDeclaration, options) {
+    const { token, imports, factory, beforeBinding, afterBinding } = moduleDeclaration;
+    const exports = moduleDeclaration.exports;
+    const scope = options === null || options === void 0 ? void 0 : options.scope;
+    if (beforeBinding) {
+        beforeBinding(container);
+    }
+    if (imports) {
+        bindModules(container, imports);
+    }
+    const exportedValueTokens = new Set();
+    if (exports) {
+        const keys = Object.keys(exports);
+        keys.forEach((valueKey) => {
+            const valueToken = exports[valueKey];
+            if (valueToken) {
+                exportedValueTokens.add(valueToken);
+                container.bindFactory(valueToken, (0, utils_1.injectable)((module) => module[valueKey], token), { scope });
+            }
+        });
+    }
+    container.bindFactory(token, factory, {
+        scope,
+        onRemoved: (module) => {
+            if (module.destroy) {
+                module.destroy();
+            }
+            exportedValueTokens.forEach((valueToken) => container.remove(valueToken));
+            exportedValueTokens.clear();
+        },
+    });
+    if (afterBinding) {
+        afterBinding(container);
+    }
+}
+exports.bindModule = bindModule;
+/**
+ * Binds dependency modules to the container
+ *
+ * @param container - Dependency container for binding
+ * @param modules - Array of module binding entries: module declaration or `{module: ModuleDeclaration, options: BindModuleOptions}` objects.
+ */
+function bindModules(container, modules) {
+    modules.forEach((entry) => {
+        if ('module' in entry) {
+            bindModule(container, entry.module, entry.options);
+        }
+        else {
+            bindModule(container, entry);
+        }
+    });
+}
+exports.bindModules = bindModules;
+/**
+ * Declares a module binding
+ *
+ * @param declaration - a module declaration
+ * @param declaration.token - optional field
+ *
+ *  @example
+ * ```ts
+ * const LOGGER_MODULE = declareModule<LoggerModule>({
+ *   factory: (container) => {
+ *     const transport = container.resolve(TRANSPORT_TOKEN).open();
+ *     return {
+ *       logger: { log: (message) => transport.write(message) },
+ *       destroy: () => transport.close(),
+ *     }
+ *   },
+ *   exports: {
+ *     logger: LOGGER_TOKEN,
+ *   },
+ * });
+ * ```
+ */
+function declareModule(declaration) {
+    var _a;
+    return { ...declaration, token: (_a = declaration.token) !== null && _a !== void 0 ? _a : (0, ditox_1.token)() };
+}
+exports.declareModule = declareModule;
+/**
+ * Declares bindings of several modules
+ *
+ * @param modules - module declaration entries
+ */
+function declareModuleBindings(modules) {
+    return declareModule({
+        factory: () => ({}),
+        imports: modules,
+    });
+}
+exports.declareModuleBindings = declareModuleBindings;
+//# sourceMappingURL=modules.js.map

package/dist/cjs/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../../src/modules.ts"],"names":[],"mappings":";;;AAAA,mCAAgD;AAChD,mCAAmC;AAqFnC;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CACxB,SAAoB,EACpB,iBAAuC,EACvC,OAA2B;IAE3B,MAAM,EAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAC,GAC1D,iBAAiB,CAAC;IACpB,MAAM,OAAO,GAAG,iBAAiB,CAAC,OAAO,CAAC;IAE1C,MAAM,KAAK,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,KAAK,CAAC;IAE7B,IAAI,aAAa,EAAE;QACjB,aAAa,CAAC,SAAS,CAAC,CAAC;KAC1B;IAED,IAAI,OAAO,EAAE;QACX,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;KACjC;IAED,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEtD,IAAI,OAAO,EAAE;QACX,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAElC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;YACxB,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;YACrC,IAAI,UAAU,EAAE;gBACd,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAEpC,SAAS,CAAC,WAAW,CACnB,UAAU,EACV,IAAA,kBAAU,EAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,EAC/C,EAAC,KAAK,EAAC,CACR,CAAC;aACH;QACH,CAAC,CAAC,CAAC;KACJ;IAED,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE;QACpC,KAAK;QACL,SAAS,EAAE,CAAC,MAAM,EAAE,EAAE;YACpB,IAAI,MAAM,CAAC,OAAO,EAAE;gBAClB,MAAM,CAAC,OAAO,EAAE,CAAC;aAClB;YAED,mBAAmB,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;YAC1E,mBAAmB,CAAC,KAAK,EAAE,CAAC;QAC9B,CAAC;KACF,CAAC,CAAC;IAEH,IAAI,YAAY,EAAE;QAChB,YAAY,CAAC,SAAS,CAAC,CAAC;KACzB;AACH,CAAC;AArDD,gCAqDC;AAED;;;;;GAKG;AACH,SAAgB,WAAW,CACzB,SAAoB,EACpB,OAA0C;IAE1C,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACxB,IAAI,QAAQ,IAAI,KAAK,EAAE;YACrB,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;SACpD;aAAM;YACL,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;SAC9B;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAXD,kCAWC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,aAAa,CAC3B,WAC8C;;IAE9C,OAAO,EAAC,GAAG,WAAW,EAAE,KAAK,EAAE,MAAA,WAAW,CAAC,KAAK,mCAAI,IAAA,aAAK,GAAE,EAAC,CAAC;AAC/D,CAAC;AALD,sCAKC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB,CACnC,OAA0C;IAE1C,OAAO,aAAa,CAAC;QACnB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;QACnB,OAAO,EAAE,OAAO;KACjB,CAAC,CAAC;AACL,CAAC;AAPD,sDAOC"}

package/dist/cjs/utils-deprecated.d.ts

@@ -0,0 +1,59 @@
+import type { Container, Token } from './ditox';
+declare type ValuesProps = {
+    [key: string]: unknown;
+};
+declare type TokenProps<Props extends ValuesProps> = {
+    [K in keyof Props]: Token<Props[K]>;
+};
+/**
+ * Returns an array of resolved values by the specified token.
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @deprecated Use `tryResolveValues()` function.
+ */
+export declare function getValues<Tokens extends Token<unknown>[], Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : never;
+}>(container: Container, ...tokens: Tokens): Values;
+/**
+ * Returns an object with resolved properties which are specified by token properties.
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @deprecated Use `tryResolveValue()` function.
+ *
+ * @example
+ * ```ts
+ * const props = getProps(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+export declare function getProps<Props extends ValuesProps>(container: Container, tokens: TokenProps<Props>): Partial<Props>;
+/**
+ * Returns an object with resolved properties which are specified by token properties.
+ * If a token is not found, then `ResolverError` is thrown.
+ *
+ * @deprecated Use `resolveValue()` function.
+ *
+ * @example
+ * ```ts
+ * const props = resolveProps(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+export declare function resolveProps<Props extends ValuesProps>(container: Container, tokens: TokenProps<Props>): Props;
+/**
+ * Decorates a factory by passing a resolved object with tokens as the first argument.
+ * @param factory - A factory.
+ * @param tokens - Object with tokens.
+ * @return Decorated factory which takes a dependency container as a single argument.
+ *
+ * @deprecated Use `injectable()` function.
+ *
+ * @example
+ * ```ts
+ * const factory = ({a, b}: {a: number, b: number}) => a + b;
+ * const decoratedFactory = injectableProps(factory, {a: tokenA, b: tokenB});
+ * const result = decoratedFactory(container);
+ * ```
+ */
+export declare function injectableProps<Props extends ValuesProps, Result>(factory: (props: Props) => Result, tokens: TokenProps<Props>): (container: Container) => Result;
+export {};

package/dist/cjs/utils-deprecated.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectableProps = exports.resolveProps = exports.getProps = exports.getValues = void 0;
+const utils_1 = require("./utils");
+/**
+ * Returns an array of resolved values by the specified token.
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @deprecated Use `tryResolveValues()` function.
+ */
+function getValues(container, ...tokens) {
+    return (0, utils_1.tryResolveValues)(container, ...tokens);
+}
+exports.getValues = getValues;
+/**
+ * Returns an object with resolved properties which are specified by token properties.
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @deprecated Use `tryResolveValue()` function.
+ *
+ * @example
+ * ```ts
+ * const props = getProps(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+function getProps(container, tokens) {
+    return (0, utils_1.tryResolveValue)(container, tokens);
+}
+exports.getProps = getProps;
+/**
+ * Returns an object with resolved properties which are specified by token properties.
+ * If a token is not found, then `ResolverError` is thrown.
+ *
+ * @deprecated Use `resolveValue()` function.
+ *
+ * @example
+ * ```ts
+ * const props = resolveProps(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+function resolveProps(container, tokens) {
+    return (0, utils_1.resolveValue)(container, tokens);
+}
+exports.resolveProps = resolveProps;
+/**
+ * Decorates a factory by passing a resolved object with tokens as the first argument.
+ * @param factory - A factory.
+ * @param tokens - Object with tokens.
+ * @return Decorated factory which takes a dependency container as a single argument.
+ *
+ * @deprecated Use `injectable()` function.
+ *
+ * @example
+ * ```ts
+ * const factory = ({a, b}: {a: number, b: number}) => a + b;
+ * const decoratedFactory = injectableProps(factory, {a: tokenA, b: tokenB});
+ * const result = decoratedFactory(container);
+ * ```
+ */
+function injectableProps(factory, tokens) {
+    return (0, utils_1.injectable)(factory, tokens);
+}
+exports.injectableProps = injectableProps;
+//# sourceMappingURL=utils-deprecated.js.map

package/dist/cjs/utils-deprecated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-deprecated.js","sourceRoot":"","sources":["../../src/utils-deprecated.ts"],"names":[],"mappings":";;;AACA,mCAKiB;AAOjB;;;;;GAKG;AACH,SAAgB,SAAS,CAKvB,SAAoB,EAAE,GAAG,MAAc;IACvC,OAAO,IAAA,wBAAgB,EAAC,SAAS,EAAE,GAAG,MAAM,CAAC,CAAC;AAChD,CAAC;AAPD,8BAOC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,QAAQ,CACtB,SAAoB,EACpB,MAAyB;IAEzB,OAAO,IAAA,uBAAe,EAAC,SAAS,EAAE,MAAM,CAAmB,CAAC;AAC9D,CAAC;AALD,4BAKC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAC1B,SAAoB,EACpB,MAAyB;IAEzB,OAAO,IAAA,oBAAY,EAAC,SAAS,EAAE,MAAM,CAAU,CAAC;AAClD,CAAC;AALD,oCAKC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,eAAe,CAC7B,OAAiC,EACjC,MAAyB;IAEzB,OAAO,IAAA,kBAAU,EAAC,OAAc,EAAE,MAAM,CAAC,CAAC;AAC5C,CAAC;AALD,0CAKC"}

package/dist/cjs/utils.d.ts

@@ -0,0 +1,136 @@
+import type { Container, Token } from './ditox';
+declare type ValuesProps = {
+    [key: string]: unknown;
+};
+declare type TokenProps<Props extends ValuesProps> = {
+    [K in keyof Props]: Token<Props[K]>;
+};
+/**
+ * Checks if a value is the token
+ */
+export declare function isToken<T>(value: unknown): value is Token<T>;
+/**
+ * Rebinds the array by the token with added new value.
+ * @param container - Dependency container.
+ * @param token - Token for an array of values.
+ * @param value - New value which is added to the end of the array.
+ */
+export declare function bindMultiValue<T>(container: Container, token: Token<ReadonlyArray<T>>, value: T): void;
+/**
+ * Tries to resolve a value by the provided token.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @example
+ * ```ts
+ * const value = tryResolveValue(container, tokenA);
+ * console.log(value); // 1
+ *
+ * const props = tryResolveValue(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+export declare function tryResolveValue<Tokens extends Token<unknown> | {
+    [key: string]: Token<unknown>;
+}, Values extends Tokens extends Token<infer V> ? V | undefined : Tokens extends TokenProps<infer Props> ? Partial<Props> : never>(container: Container, token: Tokens): Values;
+/**
+ * Returns an array of resolved values or objects with resolved values.
+ *
+ * If an item of the array is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @example
+ * ```ts
+ * const items1 = tryResolveValues(container, tokenA);
+ * console.log(items1); // [1]
+ *
+ * const items2 = tryResolveValues(container, tokenA, {a: tokenA, b: tokenB});
+ * console.log(items2); // [1, {a: 1, b: 2}]
+ * ```
+ */
+export declare function tryResolveValues<Tokens extends (Token<unknown> | {
+    [key: string]: Token<unknown>;
+})[], Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V | undefined : Tokens[K] extends TokenProps<infer Props> ? Partial<Props> : never;
+}>(container: Container, ...tokens: Tokens): Values;
+/**
+ * Resolves a value by the provided token.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a value is not found by the token, then `ResolverError` is thrown.
+ *
+ * @example
+ * ```ts
+ * const value = resolveValue(container, tokenA);
+ * console.log(value); // 1
+ *
+ * const props = resolveValue(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+export declare function resolveValue<Tokens extends Token<unknown> | {
+    [key: string]: Token<unknown>;
+}, Values extends Tokens extends Token<infer V> ? V : Tokens extends TokenProps<infer Props> ? Props : never>(container: Container, token: Tokens): Values;
+/**
+ * Returns an array of resolved values or objects with resolved values.
+ *
+ * If an item of the array is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a token is not found, then `ResolverError` is thrown.
+ *
+ * @example
+ * ```ts
+ * const items1 = resolveValues(container, tokenA);
+ * console.log(items1); // [1]
+ *
+ * const items2 = resolveValues(container, tokenA, {a: tokenA, b: tokenB});
+ * console.log(items2); // [1, {a: 1, b: 2}]
+ * ```
+ */
+export declare function resolveValues<Tokens extends (Token<unknown> | {
+    [key: string]: Token<unknown>;
+})[], Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : Tokens[K] extends TokenProps<infer Props> ? Props : never;
+}>(container: Container, ...tokens: Tokens): Values;
+/**
+ * Decorates a factory by passing resolved values as factory arguments.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+ *
+ * @param factory - A factory.
+ * @param tokens - Tokens which correspond to factory arguments.
+ *
+ * @return Decorated factory which takes a dependency container as a single argument.
+ */
+export declare function injectable<Tokens extends (Token<unknown> | {
+    [key: string]: Token<unknown>;
+})[], Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : Tokens[K] extends TokenProps<infer Props> ? Props : never;
+}, Result>(this: unknown, factory: (...params: Values) => Result, ...tokens: Tokens): (container: Container) => Result;
+/**
+ * Decorates a class by passing resolved values as arguments to its constructor.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+ *
+ * @param constructor - Constructor of a class
+ * @param tokens - Tokens which correspond to constructor arguments
+ *
+ * @return A factory function which takes a dependency container as a single argument
+ * and returns a new created class.
+ */
+export declare function injectableClass<Tokens extends (Token<unknown> | {
+    [key: string]: Token<unknown>;
+})[], Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : Tokens[K] extends TokenProps<infer Props> ? Props : never;
+}, Result>(this: unknown, constructor: new (...params: Values) => Result, ...tokens: Tokens): (container: Container) => Result;
+export {};

package/dist/cjs/utils.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectableClass = exports.injectable = exports.resolveValues = exports.resolveValue = exports.tryResolveValues = exports.tryResolveValue = exports.bindMultiValue = exports.isToken = void 0;
+/**
+ * Checks if a value is the token
+ */
+function isToken(value) {
+    return (value !== undefined &&
+        value !== null &&
+        typeof value === 'object' &&
+        'symbol' in value &&
+        typeof value.symbol === 'symbol');
+}
+exports.isToken = isToken;
+/**
+ * Rebinds the array by the token with added new value.
+ * @param container - Dependency container.
+ * @param token - Token for an array of values.
+ * @param value - New value which is added to the end of the array.
+ */
+function bindMultiValue(container, token, value) {
+    var _a;
+    const prevValues = (_a = container.get(token)) !== null && _a !== void 0 ? _a : [];
+    const nextValues = [...prevValues, value];
+    container.bindValue(token, nextValues);
+}
+exports.bindMultiValue = bindMultiValue;
+/**
+ * Tries to resolve a value by the provided token.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @example
+ * ```ts
+ * const value = tryResolveValue(container, tokenA);
+ * console.log(value); // 1
+ *
+ * const props = tryResolveValue(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+function tryResolveValue(container, token) {
+    if (isToken(token)) {
+        return container.get(token);
+    }
+    const obj = {};
+    Object.keys(token).forEach((key) => (obj[key] = container.get(token[key])));
+    return obj;
+}
+exports.tryResolveValue = tryResolveValue;
+/**
+ * Returns an array of resolved values or objects with resolved values.
+ *
+ * If an item of the array is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @example
+ * ```ts
+ * const items1 = tryResolveValues(container, tokenA);
+ * console.log(items1); // [1]
+ *
+ * const items2 = tryResolveValues(container, tokenA, {a: tokenA, b: tokenB});
+ * console.log(items2); // [1, {a: 1, b: 2}]
+ * ```
+ */
+function tryResolveValues(container, ...tokens) {
+    return tokens.map((item) => tryResolveValue(container, item));
+}
+exports.tryResolveValues = tryResolveValues;
+/**
+ * Resolves a value by the provided token.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a value is not found by the token, then `ResolverError` is thrown.
+ *
+ * @example
+ * ```ts
+ * const value = resolveValue(container, tokenA);
+ * console.log(value); // 1
+ *
+ * const props = resolveValue(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+function resolveValue(container, token) {
+    if (isToken(token)) {
+        return container.resolve(token);
+    }
+    const obj = {};
+    Object.keys(token).forEach((key) => (obj[key] = container.resolve(token[key])));
+    return obj;
+}
+exports.resolveValue = resolveValue;
+/**
+ * Returns an array of resolved values or objects with resolved values.
+ *
+ * If an item of the array is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+
+ * If a token is not found, then `ResolverError` is thrown.
+ *
+ * @example
+ * ```ts
+ * const items1 = resolveValues(container, tokenA);
+ * console.log(items1); // [1]
+ *
+ * const items2 = resolveValues(container, tokenA, {a: tokenA, b: tokenB});
+ * console.log(items2); // [1, {a: 1, b: 2}]
+ * ```
+ */
+function resolveValues(container, ...tokens) {
+    return tokens.map((item) => resolveValue(container, item));
+}
+exports.resolveValues = resolveValues;
+/**
+ * Decorates a factory by passing resolved values as factory arguments.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+ *
+ * @param factory - A factory.
+ * @param tokens - Tokens which correspond to factory arguments.
+ *
+ * @return Decorated factory which takes a dependency container as a single argument.
+ */
+function injectable(factory, ...tokens) {
+    return (container) => {
+        const values = resolveValues(container, ...tokens);
+        return factory.apply(this, values);
+    };
+}
+exports.injectable = injectable;
+/**
+ * Decorates a class by passing resolved values as arguments to its constructor.
+ *
+ * If an argument is an object which has tokens as its properties,
+ * then returns an object containing resolved values as properties.
+ *
+ * @param constructor - Constructor of a class
+ * @param tokens - Tokens which correspond to constructor arguments
+ *
+ * @return A factory function which takes a dependency container as a single argument
+ * and returns a new created class.
+ */
+function injectableClass(constructor, ...tokens) {
+    return injectable((...values) => new constructor(...values), ...tokens);
+}
+exports.injectableClass = injectableClass;
+//# sourceMappingURL=utils.js.map