@spinajs/di 2.0.180 → 2.0.182

package/lib/mjs/binder.js

@@ -1,93 +1,93 @@
-import { BindException } from './exceptions.js';
-import { ResolveType } from './enums.js';
-import { isFactory, isConstructor, getTypeName } from './helpers.js';
-import { DI } from './index.js';
-export class Binder {
-    constructor(implementation, container) {
-        this.implementation = implementation;
-        this.container = container;
-        this.isFactory = isFactory(implementation);
-        this.isConstructor = isConstructor(implementation);
-    }
-    as(type) {
-        this.container.Registry.register(type, this.implementation);
-        const iType = getTypeName(this.implementation);
-        const tType = getTypeName(type);
-        this.container.emit(`di.registered.${iType}`, this.implementation);
-        this.container.emit(`di.registered.${tType}`, this.implementation);
-        return this;
-    }
-    /**
-     * Add plain value to container. If value exists, it overrides content in  container cache
-     *
-     * @param type - name of added value
-     * @param override - if true, any value registered before is overriden by new one
-     * @returns
-     */
-    asValue(type, override = false) {
-        if (override) {
-            if (this.container.Cache.has(type)) {
-                this.container.Cache.remove(type);
-            }
-        }
-        this.container.Cache.add(type, this.implementation);
-        const tType = getTypeName(type);
-        this.container.emit(`di.registered.${tType}`, this.implementation);
-        return this;
-    }
-    /**
-     *
-     * Add plain value to container, value is stored in hashmap for quick access
-     * eg. we have multiple value converters and we wanc o(1) access, instead searching for
-     * converter for specific type
-     *
-     * @param type - name of added value
-     * @param key - hashmap key
-     */
-    asMapValue(type, key) {
-        let map = null;
-        if (this.container.Cache.has(type)) {
-            map = this.container.Cache.get(type)[0];
-        }
-        else {
-            map = new Map();
-            this.container.Cache.add(type, map);
-        }
-        map.set(key, this.implementation);
-        const iType = getTypeName(this.implementation);
-        const tType = getTypeName(type);
-        this.container.emit(`di.registered.${iType}`, this.implementation);
-        this.container.emit(`di.registered.${tType}`, this.implementation);
-        return this;
-    }
-    /**
-     * Register type as itself. Usefull when we also want to register type as self instead of base class
-     * so we can retrieve just this specific instance.
-     * @returns this
-     */
-    asSelf() {
-        if (!this.isConstructor || this.isFactory) {
-            throw new BindException('cannot register as self non class');
-        }
-        // we can safly cast to any, we checked params earlier
-        this.container.Registry.register(this.implementation, this.implementation);
-        const iType = getTypeName(this.implementation);
-        this.container.emit(`di.registered.${iType}`, this.implementation);
-        return this;
-    }
-    /**
-     * Mark type as SingleInstance resolve strategy.
-     * @returns this
-     */
-    singleInstance() {
-        if (this.isFactory || !this.isConstructor) {
-            throw new BindException('Cannot bind factory function as singleton.');
-        }
-        else {
-            const descriptor = DI.RootContainer.extractDescriptor(this.implementation);
-            descriptor.resolver = ResolveType.Singleton;
-        }
-        return this;
-    }
-}
+import { BindException } from './exceptions.js';
+import { ResolveType } from './enums.js';
+import { isFactory, isConstructor, getTypeName } from './helpers.js';
+import { DI } from './index.js';
+export class Binder {
+    constructor(implementation, container) {
+        this.implementation = implementation;
+        this.container = container;
+        this.isFactory = isFactory(implementation);
+        this.isConstructor = isConstructor(implementation);
+    }
+    as(type) {
+        this.container.Registry.register(type, this.implementation);
+        const iType = getTypeName(this.implementation);
+        const tType = getTypeName(type);
+        this.container.emit(`di.registered.${iType}`, this.implementation);
+        this.container.emit(`di.registered.${tType}`, this.implementation);
+        return this;
+    }
+    /**
+     * Add plain value to container. If value exists, it overrides content in  container cache
+     *
+     * @param type - name of added value
+     * @param override - if true, any value registered before is overriden by new one
+     * @returns
+     */
+    asValue(type, override = false) {
+        if (override) {
+            if (this.container.Cache.has(type)) {
+                this.container.Cache.remove(type);
+            }
+        }
+        this.container.Cache.add(type, this.implementation);
+        const tType = getTypeName(type);
+        this.container.emit(`di.registered.${tType}`, this.implementation);
+        return this;
+    }
+    /**
+     *
+     * Add plain value to container, value is stored in hashmap for quick access
+     * eg. we have multiple value converters and we wanc o(1) access, instead searching for
+     * converter for specific type
+     *
+     * @param type - name of added value
+     * @param key - hashmap key
+     */
+    asMapValue(type, key) {
+        let map = null;
+        if (this.container.Cache.has(type)) {
+            map = this.container.Cache.get(type)[0];
+        }
+        else {
+            map = new Map();
+            this.container.Cache.add(type, map);
+        }
+        map.set(key, this.implementation);
+        const iType = getTypeName(this.implementation);
+        const tType = getTypeName(type);
+        this.container.emit(`di.registered.${iType}`, this.implementation);
+        this.container.emit(`di.registered.${tType}`, this.implementation);
+        return this;
+    }
+    /**
+     * Register type as itself. Usefull when we also want to register type as self instead of base class
+     * so we can retrieve just this specific instance.
+     * @returns this
+     */
+    asSelf() {
+        if (!this.isConstructor || this.isFactory) {
+            throw new BindException('cannot register as self non class');
+        }
+        // we can safly cast to any, we checked params earlier
+        this.container.Registry.register(this.implementation, this.implementation);
+        const iType = getTypeName(this.implementation);
+        this.container.emit(`di.registered.${iType}`, this.implementation);
+        return this;
+    }
+    /**
+     * Mark type as SingleInstance resolve strategy.
+     * @returns this
+     */
+    singleInstance() {
+        if (this.isFactory || !this.isConstructor) {
+            throw new BindException('Cannot bind factory function as singleton.');
+        }
+        else {
+            const descriptor = DI.RootContainer.extractDescriptor(this.implementation);
+            descriptor.resolver = ResolveType.Singleton;
+        }
+        return this;
+    }
+}
 //# sourceMappingURL=binder.js.map

package/lib/mjs/container-cache.d.ts

@@ -1,18 +1,18 @@
-import { TypedArray } from './array.js';
-import { IContainer } from './interfaces.js';
-import { Class } from './types.js';
-export declare class ContainerCache {
-    private container;
-    private cache;
-    constructor(container: IContainer);
-    [Symbol.iterator](): Generator<{
-        key: string;
-        value: any;
-    }, void, unknown>;
-    remove(key: string | Class<any> | TypedArray<any>, parent?: boolean): void;
-    add(key: string | Class<any> | object, instance: any): void;
-    has(key: string | Class<any> | object | TypedArray<any>, parent?: boolean): boolean;
-    get(key: string | Class<any> | TypedArray<any>, parent?: boolean): any;
-    clear(): void;
-}
+import { TypedArray } from './array.js';
+import { IContainer } from './interfaces.js';
+import { Class } from './types.js';
+export declare class ContainerCache {
+    private container;
+    private cache;
+    constructor(container: IContainer);
+    [Symbol.iterator](): Generator<{
+        key: string;
+        value: any;
+    }, void, unknown>;
+    remove(key: string | Class<any> | TypedArray<any>, parent?: boolean): void;
+    add(key: string | Class<any> | object, instance: any): void;
+    has(key: string | Class<any> | object | TypedArray<any>, parent?: boolean): boolean;
+    get(key: string | Class<any> | TypedArray<any>, parent?: boolean): any;
+    clear(): void;
+}
 //# sourceMappingURL=container-cache.d.ts.map

package/lib/mjs/container-cache.js

@@ -1,60 +1,60 @@
-import { getTypeName } from './helpers.js';
-export class ContainerCache {
-    constructor(container) {
-        this.container = container;
-        this.cache = new Map();
-        // add to cache container
-        // so we can inject container if needed
-        this.add(container, container);
-    }
-    *[Symbol.iterator]() {
-        for (const [key, value] of this.cache) {
-            for (const v of value) {
-                yield { key, value: v };
-            }
-        }
-    }
-    remove(key, parent) {
-        if (this.has(key)) {
-            this.cache.delete(getTypeName(key));
-        }
-        else if (parent && this.container.Parent) {
-            this.container.Parent.uncache(key);
-        }
-    }
-    add(key, instance) {
-        const tName = getTypeName(key);
-        if (this.has(key)) {
-            if (this.cache.get(tName).indexOf(instance) === -1) {
-                this.cache.get(tName).push(instance);
-            }
-        }
-        else {
-            this.cache.set(tName, [instance]);
-        }
-    }
-    has(key, parent) {
-        if (this.cache.has(getTypeName(key))) {
-            return true;
-        }
-        if (parent && this.container.Parent) {
-            return this.container.Parent.Cache.has(key, parent);
-        }
-        return false;
-    }
-    get(key, parent) {
-        const tName = getTypeName(key);
-        if (this.cache.has(tName)) {
-            return this.cache.get(tName);
-        }
-        if (parent && this.container.Parent) {
-            return this.container.Parent.Cache.get(key, parent);
-        }
-        return [];
-    }
-    clear() {
-        this.cache.clear();
-        this.add(this.container, this.container);
-    }
-}
+import { getTypeName } from './helpers.js';
+export class ContainerCache {
+    constructor(container) {
+        this.container = container;
+        this.cache = new Map();
+        // add to cache container
+        // so we can inject container if needed
+        this.add(container, container);
+    }
+    *[Symbol.iterator]() {
+        for (const [key, value] of this.cache) {
+            for (const v of value) {
+                yield { key, value: v };
+            }
+        }
+    }
+    remove(key, parent) {
+        if (this.has(key)) {
+            this.cache.delete(getTypeName(key));
+        }
+        else if (parent && this.container.Parent) {
+            this.container.Parent.uncache(key);
+        }
+    }
+    add(key, instance) {
+        const tName = getTypeName(key);
+        if (this.has(key)) {
+            if (this.cache.get(tName).indexOf(instance) === -1) {
+                this.cache.get(tName).push(instance);
+            }
+        }
+        else {
+            this.cache.set(tName, [instance]);
+        }
+    }
+    has(key, parent) {
+        if (this.cache.has(getTypeName(key))) {
+            return true;
+        }
+        if (parent && this.container.Parent) {
+            return this.container.Parent.Cache.has(key, parent);
+        }
+        return false;
+    }
+    get(key, parent) {
+        const tName = getTypeName(key);
+        if (this.cache.has(tName)) {
+            return this.cache.get(tName);
+        }
+        if (parent && this.container.Parent) {
+            return this.container.Parent.Cache.get(key, parent);
+        }
+        return [];
+    }
+    clear() {
+        this.cache.clear();
+        this.add(this.container, this.container);
+    }
+}
 //# sourceMappingURL=container-cache.js.map

package/lib/mjs/container.d.ts

@@ -1,134 +1,134 @@
-/// <reference types="node" resolution-mode="require"/>
-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" resolution-mode="require"/>
+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