@pulzar/core/dist/di/zero-reflection.d.ts

Next-generation Node.js framework for ultra-fast web applications with zero-reflection DI, GraphQL, WebSockets, events, and edge runtime support

/**
 * Zero-Reflection Dependency Injection System
 *
 * This system compiles dependency graphs at build time instead of using
 * runtime reflection, resulting in:
 * - 2-3x better performance
 * - Lower memory usage
 * - Faster startup times
 * - Better tree-shaking
 */
export type Constructor<T = {}> = new (...args: any[]) => T;
export type Factory<T = any> = (...args: any[]) => T | Promise<T>;
export type Token<T = any> = string | symbol | Constructor<T>;
export type Scope = "singleton" | "transient" | "request";
export interface ClassProvider<T = any> {
    token: Token<T>;
    useClass: Constructor<T>;
    deps?: Token[];
    scope?: Scope;
    singleton?: boolean;
}
export interface ValueProvider<T = any> {
    token: Token<T>;
    useValue: T;
    scope?: "singleton";
}
export interface FactoryProvider<T = any> {
    token: Token<T>;
    useFactory: Factory<T>;
    deps?: Token[];
    scope?: Scope;
    singleton?: boolean;
}
export type Provider<T = any> = ClassProvider<T> | ValueProvider<T> | FactoryProvider<T>;
export interface CompiledProvider {
    token: Token;
    factory: (container: FastContainer) => any;
    deps: Token[];
    scope: Scope;
    singleton: boolean;
    index: number;
}
export interface CompiledContainer {
    providers: Map<Token, CompiledProvider>;
    singletons: Map<Token, any>;
    resolutionOrder: Token[];
}
export declare class DICompiler {
    private providers;
    private compiled;
    register<T>(provider: Provider<T>): this;
    compile(): CompiledContainer;
    private getDependencies;
    private compileProvider;
}
export declare class FastContainer {
    protected compiled: CompiledContainer;
    protected instances: any[];
    protected requestInstances: Map<number, any> | undefined;
    protected requestId: string | undefined;
    constructor(compiled: CompiledContainer, requestId?: string);
    resolve<T>(token: Token<T>): T;
    private resolveSingleton;
    private resolveTransient;
    private resolveRequest;
    resolveAll<T extends Record<string, Token>>(tokens: T): {
        [K in keyof T]: any;
    };
    resolveAsync<T>(token: Token<T>): Promise<T>;
    has(token: Token): boolean;
    createScope(): FastContainer;
    createRequestScope(requestId?: string): FastContainer;
    isRequestScoped(): boolean;
    getRequestId(): string | undefined;
    overrideProvider<T>(token: Token<T>, provider: Provider<T>): FastContainer;
}
export declare function defineProviders(): {
    provide<T>(token: Token<T>): {
        useClass(cls: Constructor<T>, deps?: Token[], singleton?: boolean): /*elided*/ any;
        useValue(value: T): /*elided*/ any;
        useFactory(factory: Factory<T>, deps?: Token[], singleton?: boolean): /*elided*/ any;
    };
    compile(): FastContainer;
};
export declare function Injectable(options?: {
    token?: Token;
    singleton?: boolean;
}): <T extends Constructor>(target: T) => T;
export declare function Inject(token: Token): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
export interface ModuleDefinition {
    providers?: Constructor[];
    imports?: ModuleDefinition[];
    exports?: Token[];
}
export declare function scanModule(module: ModuleDefinition): DICompiler;
export declare function createToken<T>(description: string): Token<T>;
export interface DIMetrics {
    resolutionTime: number;
    instanceCount: number;
    cacheHits: number;
    cacheMisses: number;
}
export declare class PerformantContainer extends FastContainer {
    private metrics;
    resolve<T>(token: Token<T>): T;
    getMetrics(): DIMetrics;
    resetMetrics(): void;
}
//# sourceMappingURL=zero-reflection.d.ts.map