ditox 1.4.1 → 2.2.0

package/src/modules.js.flow

@@ -1,156 +0,0 @@
-// @flow strict
-
-import type {Container, Token} from './ditox';
-import {token} from './ditox';
-import type {TokenProps, ValueProps} from './utils';
-
-type ModuleController = {
-  /** Dispose the module and clean its resources */
-  destroy?: () => void,
-};
-
-/**
- * Dependency module
- *
- * @example
- * ```ts
- * type LoggerModule = Module<{
- *   logger: Logger;
- * }>;
- * ```
- */
-export type Module<ModuleProps: ValueProps = {}> = {
-  ...ModuleController,
-  ...ModuleProps,
-};
-
-/**
- * Description of a dependency 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 type ModuleDeclaration<T: Module<*>> = {
-  /** 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?: $Shape<TokenProps<T>>,
-
-  /**
-   * Dictionary of module properties which are bound to tokens.
-   *
-   * @deprecated Use `exports` property
-   */
-  exportedProps?: $Shape<TokenProps<T>>,
-
-  /** 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 type BindModuleOptions = {
-  scope?: 'scoped' | 'singleton',
-};
-
-/**
- * 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 export function bindModule<T: Module<*>>(
-  container: Container,
-  moduleDeclaration: ModuleDeclaration<T>,
-  options?: BindModuleOptions,
-): void;
-
-export type ModuleBindingEntry =
-  | ModuleDeclaration<*>
-  | {
-      module: ModuleDeclaration<*>,
-      options: BindModuleOptions,
-    };
-
-/**
- * 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 export 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(),
- *     }
- *   },
- *   exportedProps: {
- *     logger: LOGGER_TOKEN,
- *   },
- * });
- * ```
- */
-declare export function declareModule<T>(
-  declaration: ModuleDeclaration<T> | {
-    ...$Rest<ModuleDeclaration<T>, {token: *}>,
-    token?: $PropertyType<ModuleDeclaration<T>, 'token'>,
-  },
-): ModuleDeclaration<T>;
-
-/**
- * Declares bindings of several modules
- *
- * @param modules - module declaration entries
- */
-declare export function declareModuleBindings(
-  modules: $ReadOnlyArray<ModuleBindingEntry>,
-): ModuleDeclaration<Module<*>>;

package/src/utils.js.flow

@@ -1,113 +0,0 @@
-// @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>;
-
-/**
- * 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<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 export function getValues<Values: ValuesTuple>(
-  container: Container,
-  ...tokens: Tokens<Values>
-): OptionalValues<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;
-
-/**
- * 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;
-
-/**
- * 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 export function getProps<Props: ValueProps>(
-  container: Container,
-  tokens: TokenProps<Props>,
-): $Shape<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 export function resolveProps<Props: ValueProps>(
-  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 export function injectableProps<Props: ValueProps, Result>(
-  factory: (props: Props) => Result,
-  tokens: TokenProps<Props>,
-): (container: Container) => Result;