@spinajs/di 2.0.180 → 2.0.182

package/lib/cjs/container.d.ts

@@ -1,134 +1,134 @@
-/// <reference types="node" />
-import 'reflect-metadata';
-import { TypedArray } from './array.js';
-import { IBind, IContainer, IInjectDescriptor, IResolvedInjection, IToInject, AsyncService, ResolvableObject } from './interfaces.js';
-import { Class, Factory } from './types.js';
-import { EventEmitter } from 'events';
-import { Registry } from './registry.js';
-import { ContainerCache } from './container-cache.js';
-/**
- * Dependency injection container implementation
- */
-export declare class Container extends EventEmitter implements IContainer {
-    /**
-     * Handles information about what is registered as what
-     * eg. that class IConfiguration should be resolved as DatabaseConfiguration etc.
-     */
-    private registry;
-    /**
-     * Singletons cache, objects that should be created only once are stored here.
-     */
-    private cache;
-    /**
-     * Parent container if avaible
-     */
-    private parent;
-    /**
-     * Returns container cache - map object with resolved classes as singletons
-     */
-    get Cache(): ContainerCache;
-    get Registry(): Registry;
-    get Parent(): IContainer;
-    constructor(parent?: IContainer);
-    /**
-     * Clears container registry and cache. shorthand for container.clearCache() && container.clearRegistry()
-     */
-    clear(): void;
-    dispose(): Promise<void>;
-    /**
-     * clears container registered types information
-     */
-    clearCache(): void;
-    /**
-     * Clears container resolved types
-     */
-    clearRegistry(): void;
-    /**
-     * Register class/interface to DI.
-     * @param type - interface object to register
-     * @throws {@link InvalidArgument} if type is null or undefined
-     */
-    register<T>(implementation: Class<T> | Factory<T> | ResolvableObject): IBind;
-    unregister<T>(implementation: string | Class<T> | Factory<T> | ResolvableObject): void;
-    uncache<T>(implementation: string | Class<T> | TypedArray<T>, parent?: boolean): void;
-    /**
-     * Creates child DI container.
-     *
-     */
-    child(): IContainer;
-    /**
-     * Gets already resolved services. Works only for singleton classes.
-     *
-     * Do not try to get service by factory func, it will always return null.
-     * If you somehowe want to cache instances created by factory functions,
-     * factory itself should do that somehow and end user should always resolve by
-     * assigned type
-     *
-     * @param serviceName - name of service to get
-     * @returns null if no service has been resolved at given name
-     */
-    get<T>(service: TypedArray<T>, parent?: boolean): T[];
-    get<T>(service: string | Class<T>, parent?: boolean): T;
-    hasRegistered<T>(service: Class<T> | string, parent?: boolean): boolean;
-    /**
-     * Checks if service is already resolved and exists in container cache.
-     * NOTE: check is only valid for classes that are singletons.
-     *
-     * @param service - service name or class to check
-     * @returns true if service instance already exists, otherwise false.
-     * @throws {@link InvalidArgument} when service is null or empty
-     */
-    isResolved<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): boolean;
-    /**
-     *
-     * Resolves single instance of class
-     *
-     * @param type - what to resolve, can be class definition or factory function
-     * @param options - options passed to constructor / factory
-     */
-    resolve<T>(type: string, options?: unknown[], check?: boolean, tType?: Class<T>): T;
-    resolve<T>(type: string, check?: boolean): T;
-    /**
-     *
-     * Resolves single instance of class
-     *
-     * @param type - what to resolve, can be class definition or factory function
-     * @param options - options passed to constructor / factory
-     */
-    resolve<T>(type: Class<T>, options?: unknown[], check?: boolean): T extends AsyncService ? Promise<T> : T;
-    resolve<T>(type: Class<T>, check?: boolean): T extends AsyncService ? Promise<T> : T;
-    /**
-     *
-     * Resolves all instances of given class. Under single definition can be registered multiple implementations.
-     *
-     * @param type - typed array of specified type. since TS does not expose array metadata and type its uses TypedArray<T> consctruct
-     * @param options - options passed to constructor / factory
-     * @param check - strict check if serivice is registered in container before resolving. Default behavior is to not check and resolve
-     *
-     */
-    resolve<T>(type: TypedArray<T>, options?: unknown[], check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
-    resolve<T>(type: TypedArray<T>, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
-    getRegisteredTypes<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): (Class<unknown> | Factory<unknown>)[];
-    private resolveType;
-    protected getNewInstance(typeToCreate: Class<unknown> | Factory<unknown>, a?: IResolvedInjection[], options?: unknown[]): Promise<unknown> | unknown;
-    hasRegisteredType<T>(source: Class<T> | string, type: Class<T> | string | TypedArray<T>, parent?: boolean): boolean;
-    protected resolveDependencies(toInject: IToInject<unknown>[]): (Promise<{
-        autoinject: boolean;
-        autoinjectKey: string;
-        instance: any;
-    }> | {
-        autoinject: boolean;
-        autoinjectKey: string;
-        instance: any;
-    })[] | Promise<({
-        autoinject: boolean;
-        autoinjectKey: string;
-        instance: any;
-    } | {
-        autoinject: boolean;
-        autoinjectKey: string;
-        instance: any;
-    })[]>;
-    extractDescriptor(type: Class<unknown>): IInjectDescriptor<unknown>;
-}
+/// <reference types="node" />
+import 'reflect-metadata';
+import { TypedArray } from './array.js';
+import { IBind, IContainer, IInjectDescriptor, IResolvedInjection, IToInject, AsyncService, ResolvableObject } from './interfaces.js';
+import { Class, Factory } from './types.js';
+import { EventEmitter } from 'events';
+import { Registry } from './registry.js';
+import { ContainerCache } from './container-cache.js';
+/**
+ * Dependency injection container implementation
+ */
+export declare class Container extends EventEmitter implements IContainer {
+    /**
+     * Handles information about what is registered as what
+     * eg. that class IConfiguration should be resolved as DatabaseConfiguration etc.
+     */
+    private registry;
+    /**
+     * Singletons cache, objects that should be created only once are stored here.
+     */
+    private cache;
+    /**
+     * Parent container if avaible
+     */
+    private parent;
+    /**
+     * Returns container cache - map object with resolved classes as singletons
+     */
+    get Cache(): ContainerCache;
+    get Registry(): Registry;
+    get Parent(): IContainer;
+    constructor(parent?: IContainer);
+    /**
+     * Clears container registry and cache. shorthand for container.clearCache() && container.clearRegistry()
+     */
+    clear(): void;
+    dispose(): Promise<void>;
+    /**
+     * clears container registered types information
+     */
+    clearCache(): void;
+    /**
+     * Clears container resolved types
+     */
+    clearRegistry(): void;
+    /**
+     * Register class/interface to DI.
+     * @param type - interface object to register
+     * @throws {@link InvalidArgument} if type is null or undefined
+     */
+    register<T>(implementation: Class<T> | Factory<T> | ResolvableObject): IBind;
+    unregister<T>(implementation: string | Class<T> | Factory<T> | ResolvableObject): void;
+    uncache<T>(implementation: string | Class<T> | TypedArray<T>, parent?: boolean): void;
+    /**
+     * Creates child DI container.
+     *
+     */
+    child(): IContainer;
+    /**
+     * Gets already resolved services. Works only for singleton classes.
+     *
+     * Do not try to get service by factory func, it will always return null.
+     * If you somehowe want to cache instances created by factory functions,
+     * factory itself should do that somehow and end user should always resolve by
+     * assigned type
+     *
+     * @param serviceName - name of service to get
+     * @returns null if no service has been resolved at given name
+     */
+    get<T>(service: TypedArray<T>, parent?: boolean): T[];
+    get<T>(service: string | Class<T>, parent?: boolean): T;
+    hasRegistered<T>(service: Class<T> | string, parent?: boolean): boolean;
+    /**
+     * Checks if service is already resolved and exists in container cache.
+     * NOTE: check is only valid for classes that are singletons.
+     *
+     * @param service - service name or class to check
+     * @returns true if service instance already exists, otherwise false.
+     * @throws {@link InvalidArgument} when service is null or empty
+     */
+    isResolved<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): boolean;
+    /**
+     *
+     * Resolves single instance of class
+     *
+     * @param type - what to resolve, can be class definition or factory function
+     * @param options - options passed to constructor / factory
+     */
+    resolve<T>(type: string, options?: unknown[], check?: boolean, tType?: Class<T>): T;
+    resolve<T>(type: string, check?: boolean): T;
+    /**
+     *
+     * Resolves single instance of class
+     *
+     * @param type - what to resolve, can be class definition or factory function
+     * @param options - options passed to constructor / factory
+     */
+    resolve<T>(type: Class<T>, options?: unknown[], check?: boolean): T extends AsyncService ? Promise<T> : T;
+    resolve<T>(type: Class<T>, check?: boolean): T extends AsyncService ? Promise<T> : T;
+    /**
+     *
+     * Resolves all instances of given class. Under single definition can be registered multiple implementations.
+     *
+     * @param type - typed array of specified type. since TS does not expose array metadata and type its uses TypedArray<T> consctruct
+     * @param options - options passed to constructor / factory
+     * @param check - strict check if serivice is registered in container before resolving. Default behavior is to not check and resolve
+     *
+     */
+    resolve<T>(type: TypedArray<T>, options?: unknown[], check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
+    resolve<T>(type: TypedArray<T>, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
+    getRegisteredTypes<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): (Class<unknown> | Factory<unknown>)[];
+    private resolveType;
+    protected getNewInstance(typeToCreate: Class<unknown> | Factory<unknown>, a?: IResolvedInjection[], options?: unknown[]): Promise<unknown> | unknown;
+    hasRegisteredType<T>(source: Class<T> | string, type: Class<T> | string | TypedArray<T>, parent?: boolean): boolean;
+    protected resolveDependencies(toInject: IToInject<unknown>[]): (Promise<{
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: any;
+    }> | {
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: any;
+    })[] | Promise<({
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: any;
+    } | {
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: any;
+    })[]>;
+    extractDescriptor(type: Class<unknown>): IInjectDescriptor<unknown>;
+}
 //# sourceMappingURL=container.d.ts.map