ditox 1.4.2 → 2.0.0

package/dist/cjs/modules.js

@@ -0,0 +1,110 @@
+"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) {
+    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, (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;AA4FnC;;;;;;;;;;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,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,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/{src/utils.js.flow → dist/cjs/utils.d.ts}

@@ -1,69 +1,40 @@
-// @flow strict
-
-import type {Container, Token} from './ditox';
-
-type ValuesTuple =
-  | [*]
-  | [*, *]
-  | [*, *, *]
-  | [*, *, *, *]
-  | [*, *, *, *, *]
-  | [*, *, *, *, *, *]
-  | [*, *, *, *, *, *, *]
-  | [*, *, *, *, *, *, *, *]
-  | [*, *, *, *, *, *, *, *, *]
-  | [*, *, *, *, *, *, *, *, *, *]
-  | [*, *, *, *, *, *, *, *, *, *, *]
-  | [*, *, *, *, *, *, *, *, *, *, *, *];
-
-type Tokens<Values: ValuesTuple> = $TupleMap<Values, <V>() => Token<V>>;
-type OptionalValues<Values: ValuesTuple> = $TupleMap<Values, <V>() => V | void>;
-
-export type mapPropToToken = <K, V>(key: K, value: V) => Token<V>;
-export type ValueProps = {[key: string]: *};
-export type TokenProps<Values: ValueProps> = $ObjMapi<Values, mapPropToToken>;
-
+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]>;
+};
 /**
  * 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.
  */
-declare export function bindMultiValue<T>(
-  container: Container,
-  token: Token<$ReadOnlyArray<T>>,
-  value: T,
-): void;
-
+export declare function bindMultiValue<T>(container: Container, token: Token<ReadonlyArray<T>>, value: T): void;
 /**
  * Returns an array of resolved values by the specified token.
  * If a token is not found, then `undefined` value is used.
  */
-declare export function getValues<Values: ValuesTuple>(
-  container: Container,
-  ...tokens: Tokens<Values>
-): OptionalValues<Values>;
-
+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 array of resolved values by the specified token.
  * If a token is not found, then `ResolverError` is thrown.
  */
-declare export function resolveValues<Values: ValuesTuple>(
-  container: Container,
-  ...tokens: Tokens<Values>
-): Values;
-
+export declare function resolveValues<Tokens extends Token<unknown>[], Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : never;
+}>(container: Container, ...tokens: Tokens): Values;
 /**
  * Decorates a factory by passing resolved tokens as factory arguments.
  * @param factory - A factory.
  * @param tokens - Tokens which correspond to factory arguments.
  * @return Decorated factory which takes a dependency container as a single argument.
  */
-declare export function injectable<Values: ValuesTuple, Result>(
-  factory: (...params: Values) => Result,
-  ...tokens: Tokens<Values>
-): (container: Container) => Result;
-
+export declare function injectable<Tokens extends Token<unknown>[], Values extends {
+    [K in keyof Tokens]: Tokens[K] extends Token<infer V> ? V : never;
+}, Result>(this: unknown, factory: (...params: Values) => Result, ...tokens: Tokens): (container: Container) => Result;
 /**
  * Returns an object with resolved properties which are specified by token properties.
  * If a token is not found, then `undefined` value is used.
@@ -74,11 +45,7 @@ declare export function injectable<Values: ValuesTuple, Result>(
  * console.log(props); // {a: 1, b: 2}
  * ```
  */
-declare export function getProps<Props: ValueProps>(
-  container: Container,
-  tokens: TokenProps<Props>,
-): $Shape<Props>;
-
+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.
@@ -89,11 +56,7 @@ declare export function getProps<Props: ValueProps>(
  * console.log(props); // {a: 1, b: 2}
  * ```
  */
-declare export function resolveProps<Props: ValueProps>(
-  container: Container,
-  tokens: TokenProps<Props>,
-): Props;
-
+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.
@@ -107,7 +70,5 @@ declare export function resolveProps<Props: ValueProps>(
  * const result = decoratedFactory(container);
  * ```
  */
-declare export function injectableProps<Props: ValueProps, Result>(
-  factory: (props: Props) => Result,
-  tokens: TokenProps<Props>,
-): (container: Container) => Result;
+export declare function injectableProps<Props extends ValuesProps, Result>(factory: (props: Props) => Result, tokens: TokenProps<Props>): (container: Container) => Result;
+export {};

package/dist/cjs/utils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectableProps = exports.resolveProps = exports.getProps = exports.injectable = exports.resolveValues = exports.getValues = exports.bindMultiValue = void 0;
+/**
+ * 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;
+/**
+ * Returns an array of resolved values by the specified token.
+ * If a token is not found, then `undefined` value is used.
+ */
+function getValues(container, ...tokens) {
+    return tokens.map(container.get);
+}
+exports.getValues = getValues;
+/**
+ * Returns an array of resolved values by the specified token.
+ * If a token is not found, then `ResolverError` is thrown.
+ */
+function resolveValues(container, ...tokens) {
+    return tokens.map(container.resolve);
+}
+exports.resolveValues = resolveValues;
+/**
+ * Decorates a factory by passing resolved tokens as factory arguments.
+ * @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;
+/**
+ * Returns an object with resolved properties which are specified by token properties.
+ * If a token is not found, then `undefined` value is used.
+ *
+ * @example
+ * ```ts
+ * const props = getProps(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+function getProps(container, tokens) {
+    const obj = { ...tokens };
+    Object.keys(obj).forEach((key) => (obj[key] = container.get(obj[key])));
+    return obj;
+}
+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.
+ *
+ * @example
+ * ```ts
+ * const props = resolveProps(container, {a: tokenA, b: tokenB});
+ * console.log(props); // {a: 1, b: 2}
+ * ```
+ */
+function resolveProps(container, tokens) {
+    const obj = { ...tokens };
+    Object.keys(obj).forEach((key) => (obj[key] = container.resolve(obj[key])));
+    return obj;
+}
+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.
+ *
+ * @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 (container) => {
+        const values = resolveProps(container, tokens);
+        return factory(values);
+    };
+}
+exports.injectableProps = injectableProps;
+//# sourceMappingURL=utils.js.map

package/dist/cjs/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":";;;AAOA;;;;;GAKG;AACH,SAAgB,cAAc,CAC5B,SAAoB,EACpB,KAA8B,EAC9B,KAAQ;;IAER,MAAM,UAAU,GAAG,MAAA,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,mCAAI,EAAE,CAAC;IAC9C,MAAM,UAAU,GAAG,CAAC,GAAG,UAAU,EAAE,KAAK,CAAC,CAAC;IAC1C,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AACzC,CAAC;AARD,wCAQC;AAED;;;GAGG;AACH,SAAgB,SAAS,CAKvB,SAAoB,EAAE,GAAG,MAAc;IACvC,OAAO,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAW,CAAC;AAC7C,CAAC;AAPD,8BAOC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAK3B,SAAoB,EAAE,GAAG,MAAc;IACvC,OAAO,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,CAAW,CAAC;AACjD,CAAC;AAPD,sCAOC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAQxB,OAAsC,EACtC,GAAG,MAAc;IAEjB,OAAO,CAAC,SAAS,EAAE,EAAE;QACnB,MAAM,MAAM,GAAW,aAAa,CAAC,SAAS,EAAE,GAAG,MAAM,CAAC,CAAC;QAC3D,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACrC,CAAC,CAAC;AACJ,CAAC;AAfD,gCAeC;AAED;;;;;;;;;GASG;AACH,SAAgB,QAAQ,CACtB,SAAoB,EACpB,MAAyB;IAEzB,MAAM,GAAG,GAAQ,EAAC,GAAG,MAAM,EAAC,CAAC;IAC7B,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,OAAO,GAAG,CAAC;AACb,CAAC;AAPD,4BAOC;AAED;;;;;;;;;GASG;AACH,SAAgB,YAAY,CAC1B,SAAoB,EACpB,MAAyB;IAEzB,MAAM,GAAG,GAAQ,EAAC,GAAG,MAAM,EAAC,CAAC;IAC7B,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5E,OAAO,GAAG,CAAC;AACb,CAAC;AAPD,oCAOC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,eAAe,CAC7B,OAAiC,EACjC,MAAyB;IAEzB,OAAO,CAAC,SAAS,EAAE,EAAE;QACnB,MAAM,MAAM,GAAU,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACtD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB,CAAC,CAAC;AACJ,CAAC;AARD,0CAQC"}

package/dist/esm/ditox.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @ignore
+ * Binding token for mandatory value
+ */
+export declare type RequiredToken<T> = {
+    symbol: symbol;
+    type?: T;
+    isOptional?: false;
+};
+/**
+ * @ignore
+ * Binding token for optional value
+ */
+export declare type OptionalToken<T> = {
+    symbol: symbol;
+    type?: T;
+    isOptional: true;
+    optionalValue: T;
+};
+/**
+ * Binding token.
+ */
+export declare type Token<T> = RequiredToken<T> | OptionalToken<T>;
+/**
+ * Creates a new binding token.
+ * @param description - Token description for better error messages.
+ */
+export declare function token<T>(description?: string): Token<T>;
+/**
+ * Decorate a token with an optional value.
+ * This value is be used as default value in case a container does not have registered token.
+ * @param token - Existed token.
+ * @param optionalValue - Default value for the resolver.
+ */
+export declare function optional<T>(token: Token<T>, optionalValue: T): OptionalToken<T>;
+export declare function optional<T>(token: Token<T>): OptionalToken<T | undefined>;
+/**
+ * ResolverError is thrown by the resolver when a token is not found in a container.
+ */
+export declare class ResolverError extends Error {
+    constructor(message: string);
+}
+/**
+ * @see https://github.com/mnasyrov/ditox#factory-lifetimes
+ */
+export declare type FactoryScope = 'scoped' | 'singleton' | 'transient';
+/**
+ * Options for factory binding.
+ *
+ * `scope` types:
+ *   - `singleton` - **This is the default**. The value is created and cached by the container which registered the factory.
+ *   - `scoped` - The value is created and cached by the container which starts resolving.
+ *   - `transient` - The value is created every time it is resolved.
+ *
+ * `scoped` and `singleton` scopes can have `onRemoved` callback. It is called when a token is removed from the container.
+ */
+export declare type FactoryOptions<T> = {
+    scope?: 'scoped' | 'singleton';
+    onRemoved?: (value: T) => void;
+} | {
+    scope: 'transient';
+};
+/**
+ * Dependency container.
+ */
+export declare type Container = {
+    /**
+     * Binds a value for the token
+     */
+    bindValue<T>(token: Token<T>, value: T): void;
+    /**
+     * Binds a factory for the token.
+     */
+    bindFactory<T>(token: Token<T>, factory: (container: Container) => T, options?: FactoryOptions<T>): void;
+    /**
+     * Checks if the token is registered in the container hierarchy.
+     */
+    hasToken(token: Token<unknown>): boolean;
+    /**
+     * Returns a resolved value by the token, or returns `undefined` in case the token is not found.
+     */
+    get<T>(token: Token<T>): T | undefined;
+    /**
+     * Returns a resolved value by the token, or throws `ResolverError` in case the token is not found.
+     */
+    resolve<T>(token: Token<T>): T;
+    /**
+     * Removes a binding for the token.
+     */
+    remove<T>(token: Token<T>): void;
+    /**
+     * Removes all bindings in the container.
+     */
+    removeAll(): void;
+};
+/** @internal */
+export declare const CONTAINER: Token<Container>;
+/** @internal */
+export declare const PARENT_CONTAINER: Token<Container>;
+/** @internal */
+export declare const RESOLVER: Token<Resolver>;
+/** @internal */
+declare const NOT_FOUND: unique symbol;
+/** @internal */
+export declare const FAKE_FACTORY: () => never;
+/** @internal */
+declare type FactoryContext<T> = {
+    factory: (container: Container) => T;
+    options?: FactoryOptions<T>;
+};
+/** @internal */
+export declare type FactoriesMap = Map<symbol, FactoryContext<any>>;
+/** @internal */
+export declare const FACTORIES_MAP: Token<FactoriesMap>;
+/** @internal */
+declare type Resolver = <T>(token: Token<T>, origin: Container) => T | typeof NOT_FOUND;
+/**
+ * Creates a new dependency container.
+ *
+ * Container can have an optional parent to chain token resolution. The parent is used in case the current container does not have a registered token.
+ *
+ * @param parentContainer - Optional parent container.
+ */
+export declare function createContainer(parentContainer?: Container): Container;
+export {};