ditox 1.4.0 → 2.1.0

package/dist/index.module.d.ts

@@ -1,301 +0,0 @@
-/**
- * @ignore
- * Binding token for mandatory value
- */
-declare type RequiredToken<T> = {
-    symbol: symbol;
-    type?: T;
-    isOptional?: false;
-};
-/**
- * @ignore
- * Binding token for optional value
- */
-declare type OptionalToken<T> = {
-    symbol: symbol;
-    type?: T;
-    isOptional: true;
-    optionalValue: T;
-};
-/**
- * Binding token.
- */
-declare type Token<T> = RequiredToken<T> | OptionalToken<T>;
-/**
- * Creates a new binding token.
- * @param description - Token description for better error messages.
- */
-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.
- */
-declare function optional<T>(token: Token<T>, optionalValue: T): OptionalToken<T>;
-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.
- */
-declare class ResolverError extends Error {
-    constructor(message: string);
-}
-/**
- * @see https://github.com/mnasyrov/ditox#factory-lifetimes
- */
-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.
- */
-declare type FactoryOptions<T> = {
-    scope?: 'scoped' | 'singleton';
-    onRemoved?: (value: T) => void;
-} | {
-    scope: 'transient';
-};
-/**
- * Dependency container.
- */
-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;
-};
-/**
- * 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.
- */
-declare function createContainer(parentContainer?: Container): Container;
-
-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 function bindMultiValue<T>(container: Container, token: Token<Array<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 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 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 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.
- *
- * @example
- * ```ts
- * const props = getProps(container, {a: tokenA, b: tokenB});
- * console.log(props); // {a: 1, b: 2}
- * ```
- */
-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.
- *
- * @example
- * ```ts
- * const props = resolveProps(container, {a: tokenA, b: tokenB});
- * console.log(props); // {a: 1, b: 2}
- * ```
- */
-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.
- *
- * @example
- * ```ts
- * const factory = ({a, b}: {a: number, b: number}) => a + b;
- * const decoratedFactory = injectableProps(factory, {a: tokenA, b: tokenB});
- * const result = decoratedFactory(container);
- * ```
- */
-declare function injectableProps<Props extends ValuesProps, Result>(factory: (props: Props) => Result, tokens: TokenProps<Props>): (container: Container) => Result;
-
-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;
- * }>;
- * ```
- */
-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,
- *   },
- * };
- * ```
- */
-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.
- */
-declare type BindModuleOptions = {
-    scope?: 'scoped' | 'singleton';
-};
-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);
- * ```
- */
-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.
- */
-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,
- *   },
- * });
- * ```
- */
-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
- */
-declare function declareModuleBindings(modules: ReadonlyArray<ModuleBindingEntry>): ModuleDeclaration<Module>;
-
-export { BindModuleOptions, Container, FactoryOptions, FactoryScope, Module, ModuleBindingEntry, ModuleDeclaration, OptionalToken, RequiredToken, ResolverError, Token, bindModule, bindModules, bindMultiValue, createContainer, declareModule, declareModuleBindings, getProps, getValues, injectable, injectableProps, optional, resolveProps, resolveValues, token };

package/dist/index.module.js

@@ -1,393 +0,0 @@
-/**
- * Creates a new binding token.
- * @param description - Token description for better error messages.
- */
-function token(description) {
-    return { symbol: Symbol(description) };
-}
-function optional(token, optionalValue) {
-    return {
-        symbol: token.symbol,
-        isOptional: true,
-        optionalValue,
-    };
-}
-/**
- * ResolverError is thrown by the resolver when a token is not found in a container.
- */
-class ResolverError extends Error {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, new.target.prototype);
-        this.name = 'ResolverError';
-    }
-}
-/** @internal */
-const CONTAINER = token('ditox.Container');
-/** @internal */
-const PARENT_CONTAINER = token('ditox.ParentContainer');
-/** @internal */
-const RESOLVER = token('ditox.Resolver');
-/** @internal */
-const NOT_FOUND = Symbol();
-/** @internal */
-const FAKE_FACTORY = () => {
-    throw new Error('FAKE_FACTORY');
-};
-/** @internal */
-const DEFAULT_SCOPE = 'singleton';
-/** @internal */
-const FACTORIES_MAP = token('ditox.FactoriesMap');
-/** @internal */
-function getScope(options) {
-    var _a;
-    return (_a = options === null || options === void 0 ? void 0 : options.scope) !== null && _a !== void 0 ? _a : DEFAULT_SCOPE;
-}
-/** @internal */
-function getOnRemoved(options) {
-    return options.scope === undefined ||
-        options.scope === 'scoped' ||
-        options.scope === 'singleton'
-        ? options.onRemoved
-        : undefined;
-}
-/** @internal */
-function isInternalToken(token) {
-    return (token.symbol === CONTAINER.symbol ||
-        token.symbol === PARENT_CONTAINER.symbol ||
-        token.symbol === RESOLVER.symbol);
-}
-/**
- * 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.
- */
-function createContainer(parentContainer) {
-    const values = new Map();
-    const factories = new Map();
-    const container = {
-        bindValue(token, value) {
-            if (isInternalToken(token)) {
-                return;
-            }
-            values.set(token.symbol, value);
-        },
-        bindFactory(token, factory, options) {
-            if (isInternalToken(token)) {
-                return;
-            }
-            factories.set(token.symbol, { factory, options });
-        },
-        remove(token) {
-            var _a;
-            if (isInternalToken(token)) {
-                return;
-            }
-            const options = (_a = factories.get(token.symbol)) === null || _a === void 0 ? void 0 : _a.options;
-            if (options) {
-                executeOnRemoved(token.symbol, options);
-            }
-            values.delete(token.symbol);
-            factories.delete(token.symbol);
-        },
-        removeAll() {
-            factories.forEach((context, tokenSymbol) => {
-                if (context.options) {
-                    executeOnRemoved(tokenSymbol, context.options);
-                }
-            });
-            values.clear();
-            factories.clear();
-            bindInternalTokens();
-        },
-        hasToken(token) {
-            var _a;
-            return (values.has(token.symbol) ||
-                factories.has(token.symbol) ||
-                ((_a = parentContainer === null || parentContainer === void 0 ? void 0 : parentContainer.hasToken(token)) !== null && _a !== void 0 ? _a : false));
-        },
-        get(token) {
-            const value = resolver(token, container);
-            if (value !== NOT_FOUND) {
-                return value;
-            }
-            if (token.isOptional) {
-                return token.optionalValue;
-            }
-            return undefined;
-        },
-        resolve(token) {
-            var _a;
-            const value = resolver(token, container);
-            if (value !== NOT_FOUND) {
-                return value;
-            }
-            if (token.isOptional) {
-                return token.optionalValue;
-            }
-            throw new ResolverError(`Token "${(_a = token.symbol.description) !== null && _a !== void 0 ? _a : ''}" is not provided`);
-        },
-    };
-    function resolver(token, origin) {
-        const value = values.get(token.symbol);
-        const hasValue = value !== undefined || values.has(token.symbol);
-        if (hasValue && origin === container) {
-            return value;
-        }
-        const factoryContext = factories.get(token.symbol);
-        if (factoryContext && factoryContext.factory !== FAKE_FACTORY) {
-            const scope = getScope(factoryContext.options);
-            switch (scope) {
-                case 'singleton': {
-                    if (hasValue) {
-                        return value;
-                    }
-                    else if (parentContainer === null || parentContainer === void 0 ? void 0 : parentContainer.hasToken(token)) {
-                        break;
-                    }
-                    else {
-                        // Cache the value in the same container where the factory is registered.
-                        const value = factoryContext.factory(container);
-                        container.bindValue(token, value);
-                        return value;
-                    }
-                }
-                case 'scoped': {
-                    // Create a value within the origin container and cache it.
-                    const value = factoryContext.factory(origin);
-                    origin.bindValue(token, value);
-                    if (origin !== container) {
-                        // Bind a fake factory with actual options to make onRemoved() works.
-                        origin.bindFactory(token, FAKE_FACTORY, factoryContext.options);
-                    }
-                    return value;
-                }
-                case 'transient': {
-                    // Create a value within the origin container and don't cache it.
-                    return factoryContext.factory(origin);
-                }
-            }
-        }
-        if (hasValue) {
-            return value;
-        }
-        const parentResolver = parentContainer === null || parentContainer === void 0 ? void 0 : parentContainer.get(RESOLVER);
-        if (parentResolver) {
-            return parentResolver(token, origin);
-        }
-        return NOT_FOUND;
-    }
-    function executeOnRemoved(tokenSymbol, options) {
-        const onRemoved = getOnRemoved(options);
-        if (onRemoved) {
-            const value = values.get(tokenSymbol);
-            if (value !== undefined || values.has(tokenSymbol)) {
-                onRemoved(value);
-            }
-        }
-    }
-    function bindInternalTokens() {
-        values.set(CONTAINER.symbol, container);
-        values.set(RESOLVER.symbol, resolver);
-        values.set(FACTORIES_MAP.symbol, factories);
-        if (parentContainer) {
-            values.set(PARENT_CONTAINER.symbol, parentContainer);
-        }
-    }
-    bindInternalTokens();
-    return container;
-}
-
-/**
- * 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);
-}
-/**
- * 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);
-}
-/**
- * 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);
-}
-/**
- * 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);
-    };
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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);
-    };
-}
-
-/**
- * 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 (imports) {
-        bindModules(container, imports);
-    }
-    if (beforeBinding) {
-        beforeBinding(container);
-    }
-    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.
- */
-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,
- *   },
- * });
- * ```
- */
-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
- */
-function declareModuleBindings(modules) {
-    return declareModule({
-        factory: () => ({}),
-        imports: modules,
-    });
-}
-
-export { ResolverError, bindModule, bindModules, bindMultiValue, createContainer, declareModule, declareModuleBindings, getProps, getValues, injectable, injectableProps, optional, resolveProps, resolveValues, token };
-//# sourceMappingURL=index.module.js.map

package/dist/index.module.js.flow

@@ -1,4 +0,0 @@
-// @flow strict
-// Generated by rollup-plugin-flow-entry
-
-export * from '../src/index.js.flow'