@mikrokit/di/dist/index.d.ts

A lightweight TypeScript dependency injection container that uses only strip-tipes compliant methodologies and does not rely on reflect-metadata

interface Injector {
    inject<T>(token: SingleProviderToken<T>, scope?: ProvideScope): Promise<T>;
    inject<T>(token: GroupProviderToken<T>, scope?: ProvideScope): Promise<T[]>;
    inject<TOriginalTokenized, T>(tokenized: Tokenized<TOriginalTokenized, T, SingleProviderToken<T>>, scope?: ProvideScope): Promise<T>;
    inject<TOriginalTokenized, T>(tokenized: Tokenized<TOriginalTokenized, T, GroupProviderToken<T>>, scope?: ProvideScope): Promise<T[]>;
}
type SingleProviderToken<T> = Symbol & {
    _: {
        provided: T;
        group: false;
    };
};
type GroupProviderToken<T> = Symbol & {
    _: {
        provided: T;
        group: true;
    };
};
type ProviderToken<T> = SingleProviderToken<T> | GroupProviderToken<T>;
type Tokenized<TOriginal, TProvider, TToken extends ProviderToken<TProvider> = ProviderToken<TProvider>> = TOriginal & {
    token: TToken;
};
type TokenizedProviderFactory<T, TToken extends ProviderToken<T>> = Tokenized<ProviderFactory<T>, T, TToken>;
type ProviderFactory<T> = (injector: Injector) => Promise<T> | T;
type ProvideOptions = {
    /**
     * If `true`, function will not throw an error if the token is already provided.
     * If the token is not provided already, it will be provided as usual
     * @default false
     * @description We only recommend using this during tests, to mock some dependencies
     */
    override: boolean;
};

type InternalGroupProviderDefinition = {
    group: true;
    factories: ProviderFactory<any>[];
};
type InternalSingleProviderDefinition = {
    group: false;
    factory: ProviderFactory<any>;
};
type InternalProviderDefinition = InternalSingleProviderDefinition | InternalGroupProviderDefinition;
declare class Module {
    moduleName?: string | undefined;
    private static readonly DEFAULT_PROVIDE_OPTIONS;
    protected providers: Map<Symbol, InternalProviderDefinition>;
    constructor(moduleName?: string | undefined, providers?: Map<Symbol, InternalProviderDefinition>);
    provide<T>(token: ProviderToken<T> | Tokenized<unknown, T>, factory: ProviderFactory<T>, options?: ProvideOptions): this;
    provide<T>(tokenizedFactory: TokenizedProviderFactory<T, ProviderToken<T>>): this;
    import(module: Module): this;
    private provideGroupToken;
    private provideSingleToken;
}
declare const createModule: () => Module;

declare enum ProvideScope {
    TRANSIENT = "transient",
    SINGLETON = "singleton"
}
declare class Container extends Module implements Injector {
    private readonly instantiatedSingleSingletonProviders;
    private readonly instantiatedGroupSingletonProviders;
    private readonly injectionStack;
    private constructor();
    static createEmpty(): Container;
    inject<T>(token: SingleProviderToken<T>, scope?: ProvideScope): Promise<T>;
    inject<T>(token: GroupProviderToken<T>, scope?: ProvideScope): Promise<T[]>;
    inject<TOriginalTokenized, T>(tokenized: Tokenized<TOriginalTokenized, T, SingleProviderToken<T>>, scope?: ProvideScope): Promise<T>;
    inject<TOriginalTokenized, T>(tokenized: Tokenized<TOriginalTokenized, T, GroupProviderToken<T>>, scope?: ProvideScope): Promise<T[]>;
    private injectSingle;
    private injectGroup;
}
declare const createContainer: () => Container;

declare const createProviderToken: <T>(_factory?: ProviderFactory<T>, name?: string) => SingleProviderToken<T>;
declare const createGroupProviderToken: <T>(name?: string) => GroupProviderToken<T>;
declare const defineProviderFactory: <T>(factory: ProviderFactory<T>) => ProviderFactory<T>;
declare const defineStaticProviderFactory: <T>(staticValue: T) => ProviderFactory<T>;
declare const attachProviderToken: <T, TToken extends ProviderToken<T>>(factory: ProviderFactory<T>, token: TToken) => TokenizedProviderFactory<T, TToken>;
declare function defineStaticProvider<T>(value: T): TokenizedProviderFactory<T, SingleProviderToken<T>>;
declare function defineStaticProvider<T, TToken extends ProviderToken<T>>(value: T, token: TToken): TokenizedProviderFactory<T, TToken>;
declare function defineProvider<T>(factory: ProviderFactory<T>, name?: string): TokenizedProviderFactory<T, SingleProviderToken<T>>;
declare function defineProvider<T, TToken extends ProviderToken<T>>(factory: ProviderFactory<T>, token: TToken): TokenizedProviderFactory<T, TToken>;

export { Container, type GroupProviderToken, type Injector, Module, ProvideScope, type ProviderFactory, type ProviderToken, type SingleProviderToken, type Tokenized, type TokenizedProviderFactory, attachProviderToken, createContainer, createGroupProviderToken, createModule, createProviderToken, defineProvider, defineProviderFactory, defineStaticProvider, defineStaticProviderFactory };