@zxh19890103/wik/model/basic/Injector.class.d.ts

The world-class JavaScript library for building large-scale digital warehouse both on 2D and 3D.

import { Constructor, AbstractConstructor } from '../../interfaces';
import { IInjector, WithInjector } from '../../interfaces';
/**
 * If parent-child relation has not created, we cannot access injector Hierarchically.
 *
 * You try to create a Child, which is a child of a Parent.
 * Both Parent and Child are providers, which means both have injector.
 * Child has dependencies of parameters and properties, some of which should come from Parent's providers.
 * Now. you firstly create an injector for Child, that's OK.
 * But how the dependencies on Parent are obtained ?
 *
 * Q: How about services are depended by each other?
 */
/**
 * be inspired of Angular2.
 * @see https://angular.io/guide/hierarchical-dependency-injection
 */
export declare class Injector implements IInjector {
    private C;
    parent: IInjector;
    private values;
    private providers;
    readonly own: WithInjector;
    readonly writeProp: (o: object, prop: string, value: any) => void;
    constructor(C: Constructor);
    /**
     * load or reload providers,
     * keep in mind! we don't  re-bind the dependencies that have already bound.
     */
    loadProviders(): void;
    $new<T extends object>(C: Constructor<T>, ...args: any[]): T;
    get<T>(token: symbol): T;
    /**
     * get a service from a provider.
     */
    private getService;
}
/**
 * must be no-argument
 */
export type InjectToken = symbol;
export type InjectDecratorArgs = [object, string, PropertyDescriptor];
export type GraphNodeTarget = AbstractConstructor;
export interface GraphNode {
    /**
     * for development
     */
    _dev_label?: string;
    /**
     * constructor parameters dependencies
     */
    paramsDeps: GraphNodeDep[];
    /**
     * Properties dependencies
     */
    deps: GraphNodeDep[];
}
export interface TargetGraphNode extends GraphNode {
    /**
     * target is the class having  deps and params deps.
     */
    target: GraphNodeTarget;
}
export interface TokenGraphNode extends GraphNode {
    /**
     * thing's token that would be injected.
     */
    token: InjectToken;
}
export type GraphNodeDep = {
    parent: TargetGraphNode;
    child: TokenGraphNode;
    /**
     * the property name
     */
    symbol: string;
};
export type Provider = {
    useClass?: Constructor;
    useValue?: any;
    useFactory?: () => any;
};
export type ConfigProviderConfigValue = Provider | Constructor;
type ProviderWithSymbol = Provider & {
    provide: symbol;
};
export declare const rootInjector: Injector;
export declare function configProviders(target: AbstractConstructor | 'root', config: Record<symbol, ConfigProviderConfigValue> | Array<ProviderWithSymbol>): void;
export declare function getGraphNode(key: GraphNodeTarget | InjectToken): GraphNode;
export declare function createGraphNodeDep(parent: TargetGraphNode, child: TokenGraphNode, symbol?: string | number): GraphNodeDep;
export {};