ditox 1.4.0 → 2.1.0

package/dist/esm/modules.d.ts

@@ -0,0 +1,124 @@
+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]>;
+    };
+    /**
+     * 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;
+    /** 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/esm/modules.js

@@ -0,0 +1,103 @@
+import { token } from './ditox';
+import { injectable } from './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);
+ * ```
+ */
+export function bindModule(container, moduleDeclaration, options) {
+    var _a;
+    const { token, imports, factory, beforeBinding, afterBinding } = moduleDeclaration;
+    const exports = (_a = moduleDeclaration.exports) !== null && _a !== void 0 ? _a : moduleDeclaration.exportedProps;
+    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, 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);
+    }
+}
+/**
+ * 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 function bindModules(container, modules) {
+    modules.forEach((entry) => {
+        if ('module' in entry) {
+            bindModule(container, entry.module, entry.options);
+        }
+        else {
+            bindModule(container, entry);
+        }
+    });
+}
+/**
+ * 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 function declareModule(declaration) {
+    var _a;
+    return { ...declaration, token: (_a = declaration.token) !== null && _a !== void 0 ? _a : token() };
+}
+/**
+ * Declares bindings of several modules
+ *
+ * @param modules - module declaration entries
+ */
+export function declareModuleBindings(modules) {
+    return declareModule({
+        factory: () => ({}),
+        imports: modules,
+    });
+}
+//# sourceMappingURL=modules.js.map

package/dist/esm/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../../src/modules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,EAAQ,MAAM,SAAS,CAAC;AAChD,OAAO,EAAC,UAAU,EAAC,MAAM,SAAS,CAAC;AA4FnC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,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,MAAA,iBAAiB,CAAC,OAAO,mCAAI,iBAAiB,CAAC,aAAa,CAAC;IAE7E,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,UAAU,CAAC,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;AAED;;;;;GAKG;AACH,MAAM,UAAU,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;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,aAAa,CAC3B,WAC8C;;IAE9C,OAAO,EAAC,GAAG,WAAW,EAAE,KAAK,EAAE,MAAA,WAAW,CAAC,KAAK,mCAAI,KAAK,EAAE,EAAC,CAAC;AAC/D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,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"}

package/dist/esm/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/esm/utils-deprecated.js

@@ -0,0 +1,59 @@
+import { injectable, resolveValue, tryResolveValue, tryResolveValues, } from './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.
+ */
+export function getValues(container, ...tokens) {
+    return tryResolveValues(container, ...tokens);
+}
+/**
+ * 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 function getProps(container, tokens) {
+    return tryResolveValue(container, tokens);
+}
+/**
+ * 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 function resolveProps(container, tokens) {
+    return resolveValue(container, tokens);
+}
+/**
+ * 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 function injectableProps(factory, tokens) {
+    return injectable(factory, tokens);
+}
+//# sourceMappingURL=utils-deprecated.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils-deprecated.js","sourceRoot":"","sources":["../../src/utils-deprecated.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAOjB;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAKvB,SAAoB,EAAE,GAAG,MAAc;IACvC,OAAO,gBAAgB,CAAC,SAAS,EAAE,GAAG,MAAM,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CACtB,SAAoB,EACpB,MAAyB;IAEzB,OAAO,eAAe,CAAC,SAAS,EAAE,MAAM,CAAmB,CAAC;AAC9D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAC1B,SAAoB,EACpB,MAAyB;IAEzB,OAAO,YAAY,CAAC,SAAS,EAAE,MAAM,CAAU,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAC7B,OAAiC,EACjC,MAAyB;IAEzB,OAAO,UAAU,CAAC,OAAc,EAAE,MAAM,CAAC,CAAC;AAC5C,CAAC"}

package/dist/esm/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/esm/utils.js

@@ -0,0 +1,145 @@
+/**
+ * Checks if a value is the token
+ */
+export function isToken(value) {
+    return (value !== undefined &&
+        value !== null &&
+        typeof value === 'object' &&
+        'symbol' in value &&
+        typeof value.symbol === 'symbol');
+}
+/**
+ * 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 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);
+}
+/**
+ * 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 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;
+}
+/**
+ * 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 function tryResolveValues(container, ...tokens) {
+    return tokens.map((item) => tryResolveValue(container, item));
+}
+/**
+ * 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 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;
+}
+/**
+ * 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 function resolveValues(container, ...tokens) {
+    return tokens.map((item) => resolveValue(container, item));
+}
+/**
+ * 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 function injectable(factory, ...tokens) {
+    return (container) => {
+        const values = resolveValues(container, ...tokens);
+        return factory.apply(this, values);
+    };
+}
+/**
+ * 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 function injectableClass(constructor, ...tokens) {
+    return injectable((...values) => new constructor(...values), ...tokens);
+}
+//# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"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"}