@spinajs/di 2.0.180 → 2.0.181

package/lib/cjs/interfaces.d.ts

@@ -1,173 +1,173 @@
-/// <reference types="node" />
-import { ResolveType } from './enums.js';
-import { Class, Factory } from './types.js';
-import { EventEmitter } from 'events';
-import { TypedArray } from './array.js';
-import { Registry } from './registry.js';
-import { ContainerCache } from './container-cache.js';
-export interface IInstanceCheck {
-    __checkInstance__(creationOptions: any): boolean;
-}
-/**
- * Class info structure
- */
-export declare class ClassInfo<T> {
-    /**
-     * Full file path of loaded class
-     */
-    file: string;
-    /**
-     * Class name
-     */
-    name: string;
-    /**
-     * Javascript class object
-     */
-    type: any;
-    /**
-     * Resolved instance
-     */
-    instance?: T;
-}
-/**
- * Interface to describe DI binding behaviour
- */
-export interface IBind {
-    /**
-     * `as` binding (alias)
-     *
-     * @param type - base class that is being registered
-     */
-    as(type: Class<any> | string): this;
-    /**
-     * self bind, class should be resolved by its name. Its default behaviour.
-     */
-    asSelf(): this;
-    /**
-     * Registers as value, it wont be resolved or called, just stored as is in container
-     * @param type - name of type / key after whitch implementation will be resolved
-     * @param override - if true, any value registered before is overriden by new one
-     */
-    asValue(type: string, override: boolean): this;
-    asValue(type: string): 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: string, hashKey: string): this;
-    /**
-     * Registers object as single instance ( singleton )
-     */
-    singleInstance(): this;
-}
-export interface ResolvableObject {
-    [key: string]: any;
-}
-export interface IContainer extends EventEmitter {
-    Cache: ContainerCache;
-    Registry: Registry;
-    Parent: IContainer;
-    clear(): void;
-    clearRegistry(): void;
-    clearCache(): void;
-    register<T>(implementation: Class<T> | Factory<T> | ResolvableObject): IBind;
-    unregister<T>(implementation: string | Class<T> | Factory<T> | ResolvableObject): void;
-    uncache<T>(source: string | Class<T> | TypedArray<T>, parent?: boolean): void;
-    child(): IContainer;
-    get<T>(service: TypedArray<T>, parent?: boolean): T[] | null;
-    get<T>(service: string | Class<T>, parent?: boolean): T | null;
-    get<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): T | T[] | null;
-    getRegisteredTypes<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): Array<Class<unknown> | Factory<unknown>>;
-    isResolved<T>(service: string | Class<T>, parent?: boolean): boolean;
-    hasRegistered<T>(service: Class<T> | string | TypedArray<T>, parent?: boolean): boolean;
-    hasRegisteredType<T>(source: Class<any> | string | TypedArray<any>, type: Class<T> | string | TypedArray<T> | object, parent?: boolean): boolean;
-    resolve<T>(type: string, options?: unknown[], check?: boolean): T;
-    resolve<T>(type: string, check?: boolean): T;
-    resolve<T>(type: Class<T> | Factory<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T> : T;
-    resolve<T>(type: TypedArray<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
-    resolve<T>(type: Class<T> | Factory<T>, check?: boolean): T extends AsyncService ? Promise<T> : T;
-    resolve<T>(type: TypedArray<T>, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
-    resolve<T>(type: Class<T> | TypedArray<T> | string, options?: unknown[] | boolean, check?: boolean): Promise<T | T[]> | T | T[];
-    dispose(): Promise<void>;
-    extractDescriptor(type: Class<unknown>): IInjectDescriptor<unknown>;
-}
-/**
- * Injection description definition structure
- */
-export interface IInjectDescriptor<T> {
-    inject: IToInject<T>[];
-    resolver: ResolveType;
-}
-export interface IToInject<T> {
-    inject: Class<T> | TypedArray<T>;
-    autoinject: boolean;
-    autoinjectKey: string;
-    /**
-     * additional data passed to DI when resolving
-     */
-    data?: any;
-    /**
-     * Additional options passed to resolved options
-     */
-    options?: any;
-    /**
-     * Callback used to resolve service
-     * name of service we want to resolve
-     * eg. we have multiple \@injectable registered
-     * and we want specific one
-     *
-     * It is specifically for use with configuration module
-     * where services can be changed in configuration files
-     * and allows to use @AutoinjectService() decorator
-     */
-    serviceFunc?: (data: string | any[], container: IContainer) => IServiceFuncResult | IServiceFuncResult[];
-    mapFunc?: (x: IMappableService) => string;
-}
-export interface IMappableService {
-    ServiceName: string;
-}
-export interface IServiceFuncResult {
-    service: string;
-    options?: any;
-}
-export interface IResolvedInjection {
-    instance: unknown;
-    autoinject: boolean;
-    autoinjectKey: string;
-}
-/**
- * Interface to describe DI resolve strategies. Strategies are used do
- * do some work at object creation eg. initialize objects that inherits from same class
- * specific way but without need for factory function.
- *
- *
- * @see FrameworkModuleSyncService implementation
- */
-export declare class Service {
-    protected resolved: boolean;
-    get Resolved(): boolean;
-    /**
-     * Use to dispose service, relase all resources, stop timers etc.
-     *
-     */
-    dispose(): Promise<void>;
-}
-export declare abstract class SyncService extends Service {
-    resolve(): void;
-}
-export declare class AsyncService extends Service {
-    resolve(): Promise<void>;
-}
-export declare abstract class Bootstrapper {
-    abstract bootstrap(): Promise<void> | void;
-}
-export interface IAutoinjectOptions {
-    mapFunc?: (x: IMappableService) => string;
-    options?: any;
-}
+/// <reference types="node" />
+import { ResolveType } from './enums.js';
+import { Class, Factory } from './types.js';
+import { EventEmitter } from 'events';
+import { TypedArray } from './array.js';
+import { Registry } from './registry.js';
+import { ContainerCache } from './container-cache.js';
+export interface IInstanceCheck {
+    __checkInstance__(creationOptions: any): boolean;
+}
+/**
+ * Class info structure
+ */
+export declare class ClassInfo<T> {
+    /**
+     * Full file path of loaded class
+     */
+    file: string;
+    /**
+     * Class name
+     */
+    name: string;
+    /**
+     * Javascript class object
+     */
+    type: any;
+    /**
+     * Resolved instance
+     */
+    instance?: T;
+}
+/**
+ * Interface to describe DI binding behaviour
+ */
+export interface IBind {
+    /**
+     * `as` binding (alias)
+     *
+     * @param type - base class that is being registered
+     */
+    as(type: Class<any> | string): this;
+    /**
+     * self bind, class should be resolved by its name. Its default behaviour.
+     */
+    asSelf(): this;
+    /**
+     * Registers as value, it wont be resolved or called, just stored as is in container
+     * @param type - name of type / key after whitch implementation will be resolved
+     * @param override - if true, any value registered before is overriden by new one
+     */
+    asValue(type: string, override: boolean): this;
+    asValue(type: string): 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: string, hashKey: string): this;
+    /**
+     * Registers object as single instance ( singleton )
+     */
+    singleInstance(): this;
+}
+export interface ResolvableObject {
+    [key: string]: any;
+}
+export interface IContainer extends EventEmitter {
+    Cache: ContainerCache;
+    Registry: Registry;
+    Parent: IContainer;
+    clear(): void;
+    clearRegistry(): void;
+    clearCache(): void;
+    register<T>(implementation: Class<T> | Factory<T> | ResolvableObject): IBind;
+    unregister<T>(implementation: string | Class<T> | Factory<T> | ResolvableObject): void;
+    uncache<T>(source: string | Class<T> | TypedArray<T>, parent?: boolean): void;
+    child(): IContainer;
+    get<T>(service: TypedArray<T>, parent?: boolean): T[] | null;
+    get<T>(service: string | Class<T>, parent?: boolean): T | null;
+    get<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): T | T[] | null;
+    getRegisteredTypes<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): Array<Class<unknown> | Factory<unknown>>;
+    isResolved<T>(service: string | Class<T>, parent?: boolean): boolean;
+    hasRegistered<T>(service: Class<T> | string | TypedArray<T>, parent?: boolean): boolean;
+    hasRegisteredType<T>(source: Class<any> | string | TypedArray<any>, type: Class<T> | string | TypedArray<T> | object, parent?: boolean): boolean;
+    resolve<T>(type: string, options?: unknown[], check?: boolean): T;
+    resolve<T>(type: string, check?: boolean): T;
+    resolve<T>(type: Class<T> | Factory<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T> : T;
+    resolve<T>(type: TypedArray<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
+    resolve<T>(type: Class<T> | Factory<T>, check?: boolean): T extends AsyncService ? Promise<T> : T;
+    resolve<T>(type: TypedArray<T>, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
+    resolve<T>(type: Class<T> | TypedArray<T> | string, options?: unknown[] | boolean, check?: boolean): Promise<T | T[]> | T | T[];
+    dispose(): Promise<void>;
+    extractDescriptor(type: Class<unknown>): IInjectDescriptor<unknown>;
+}
+/**
+ * Injection description definition structure
+ */
+export interface IInjectDescriptor<T> {
+    inject: IToInject<T>[];
+    resolver: ResolveType;
+}
+export interface IToInject<T> {
+    inject: Class<T> | TypedArray<T>;
+    autoinject: boolean;
+    autoinjectKey: string;
+    /**
+     * additional data passed to DI when resolving
+     */
+    data?: any;
+    /**
+     * Additional options passed to resolved options
+     */
+    options?: any;
+    /**
+     * Callback used to resolve service
+     * name of service we want to resolve
+     * eg. we have multiple \@injectable registered
+     * and we want specific one
+     *
+     * It is specifically for use with configuration module
+     * where services can be changed in configuration files
+     * and allows to use @AutoinjectService() decorator
+     */
+    serviceFunc?: (data: string | any[], container: IContainer) => IServiceFuncResult | IServiceFuncResult[];
+    mapFunc?: (x: IMappableService) => string;
+}
+export interface IMappableService {
+    ServiceName: string;
+}
+export interface IServiceFuncResult {
+    service: string;
+    options?: any;
+}
+export interface IResolvedInjection {
+    instance: unknown;
+    autoinject: boolean;
+    autoinjectKey: string;
+}
+/**
+ * Interface to describe DI resolve strategies. Strategies are used do
+ * do some work at object creation eg. initialize objects that inherits from same class
+ * specific way but without need for factory function.
+ *
+ *
+ * @see FrameworkModuleSyncService implementation
+ */
+export declare class Service {
+    protected resolved: boolean;
+    get Resolved(): boolean;
+    /**
+     * Use to dispose service, relase all resources, stop timers etc.
+     *
+     */
+    dispose(): Promise<void>;
+}
+export declare abstract class SyncService extends Service {
+    resolve(): void;
+}
+export declare class AsyncService extends Service {
+    resolve(): Promise<void>;
+}
+export declare abstract class Bootstrapper {
+    abstract bootstrap(): Promise<void> | void;
+}
+export interface IAutoinjectOptions {
+    mapFunc?: (x: IMappableService) => string;
+    options?: any;
+}
 //# sourceMappingURL=interfaces.d.ts.map

package/lib/cjs/interfaces.js

@@ -1,54 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bootstrapper = exports.AsyncService = exports.SyncService = exports.Service = exports.ClassInfo = void 0;
-/**
- * Class info structure
- */
-class ClassInfo {
-}
-exports.ClassInfo = ClassInfo;
-/**
- * Interface to describe DI resolve strategies. Strategies are used do
- * do some work at object creation eg. initialize objects that inherits from same class
- * specific way but without need for factory function.
- *
- *
- * @see FrameworkModuleSyncService implementation
- */
-// export interface IStrategy {
-//     resolve: (target: any, container: IContainer) => void;
-// }
-// export interface IAsyncStrategy {
-//     resolveA: (target: any, container: IContainer) => Promise<void>;
-// }
-class Service {
-    constructor() {
-        this.resolved = false;
-    }
-    get Resolved() {
-        return this.resolved;
-    }
-    /**
-     * Use to dispose service, relase all resources, stop timers etc.
-     *
-     */
-    async dispose() { }
-}
-exports.Service = Service;
-class SyncService extends Service {
-    resolve() {
-        this.resolved = true;
-    }
-}
-exports.SyncService = SyncService;
-class AsyncService extends Service {
-    /* eslint-disable */
-    async resolve() {
-        this.resolved = true;
-    }
-}
-exports.AsyncService = AsyncService;
-class Bootstrapper {
-}
-exports.Bootstrapper = Bootstrapper;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bootstrapper = exports.AsyncService = exports.SyncService = exports.Service = exports.ClassInfo = void 0;
+/**
+ * Class info structure
+ */
+class ClassInfo {
+}
+exports.ClassInfo = ClassInfo;
+/**
+ * Interface to describe DI resolve strategies. Strategies are used do
+ * do some work at object creation eg. initialize objects that inherits from same class
+ * specific way but without need for factory function.
+ *
+ *
+ * @see FrameworkModuleSyncService implementation
+ */
+// export interface IStrategy {
+//     resolve: (target: any, container: IContainer) => void;
+// }
+// export interface IAsyncStrategy {
+//     resolveA: (target: any, container: IContainer) => Promise<void>;
+// }
+class Service {
+    constructor() {
+        this.resolved = false;
+    }
+    get Resolved() {
+        return this.resolved;
+    }
+    /**
+     * Use to dispose service, relase all resources, stop timers etc.
+     *
+     */
+    async dispose() { }
+}
+exports.Service = Service;
+class SyncService extends Service {
+    resolve() {
+        this.resolved = true;
+    }
+}
+exports.SyncService = SyncService;
+class AsyncService extends Service {
+    /* eslint-disable */
+    async resolve() {
+        this.resolved = true;
+    }
+}
+exports.AsyncService = AsyncService;
+class Bootstrapper {
+}
+exports.Bootstrapper = Bootstrapper;
 //# sourceMappingURL=interfaces.js.map

package/lib/cjs/registry.d.ts

@@ -1,15 +1,15 @@
-import { TypedArray } from './array.js';
-import { IContainer } from './interfaces.js';
-import { Class, Factory } from './types.js';
-export declare class Registry {
-    protected container: IContainer;
-    protected registry: Map<string, any[]>;
-    constructor(container: IContainer);
-    clear(): void;
-    unregister(type: any): void;
-    register(name: string | Class<any> | TypedArray<any>, type: any): void;
-    hasRegisteredType(source: Class<any> | string | TypedArray<any>, type: Class<any> | string | TypedArray<any> | object, parent?: boolean): boolean;
-    getTypes<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): Array<Class<unknown> | Factory<unknown>>;
-    hasRegistered<T>(service: TypedArray<T> | Class<T> | string, parent?: boolean): boolean;
-}
+import { TypedArray } from './array.js';
+import { IContainer } from './interfaces.js';
+import { Class, Factory } from './types.js';
+export declare class Registry {
+    protected container: IContainer;
+    protected registry: Map<string, any[]>;
+    constructor(container: IContainer);
+    clear(): void;
+    unregister(type: any): void;
+    register(name: string | Class<any> | TypedArray<any>, type: any): void;
+    hasRegisteredType(source: Class<any> | string | TypedArray<any>, type: Class<any> | string | TypedArray<any> | object, parent?: boolean): boolean;
+    getTypes<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): Array<Class<unknown> | Factory<unknown>>;
+    hasRegistered<T>(service: TypedArray<T> | Class<T> | string, parent?: boolean): boolean;
+}
 //# sourceMappingURL=registry.d.ts.map

package/lib/cjs/registry.js

@@ -1,81 +1,81 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Registry = void 0;
-const exceptions_1 = require("@spinajs/exceptions");
-const helpers_js_1 = require("./helpers.js");
-class Registry {
-    constructor(container) {
-        this.container = container;
-        this.registry = new Map();
-    }
-    clear() {
-        this.registry.clear();
-    }
-    unregister(type) {
-        const tname = (0, helpers_js_1.getTypeName)(type);
-        this.registry.forEach((value) => {
-            const index = value.findIndex((x) => (0, helpers_js_1.getTypeName)(x) === tname);
-            if (index !== -1) {
-                value.splice(index, 1);
-            }
-        });
-    }
-    register(name, type) {
-        if (!(0, helpers_js_1.isConstructor)(type) && !(0, helpers_js_1.isFactory)(type) && !(0, helpers_js_1.isObject)(type)) {
-            throw new exceptions_1.InvalidOperation('cannot register type if its not an class or factory function');
-        }
-        else {
-            const tname = (0, helpers_js_1.getTypeName)(name);
-            const value = this.registry.get(tname);
-            if (value) {
-                // factory functions, we always add to registry
-                // its impossible to check for duplicates
-                // all would return 'Function' type
-                if ((0, helpers_js_1.isFactory)(type)) {
-                    value.push(type);
-                }
-                else if (!value.find((v) => (0, helpers_js_1.getTypeName)(v) === (0, helpers_js_1.getTypeName)(type))) {
-                    value.push(type);
-                }
-            }
-            else {
-                this.registry.set(tname, [type]);
-            }
-        }
-    }
-    hasRegisteredType(source, type, parent) {
-        const sourceName = (0, helpers_js_1.getTypeName)(source);
-        const targetName = (0, helpers_js_1.getTypeName)(type);
-        if (this.registry.has(sourceName)) {
-            return this.registry.get(sourceName).find((s) => s.name === targetName) !== undefined;
-        }
-        else if (parent && this.container.Parent) {
-            return this.container.Parent.hasRegisteredType(source, type, parent);
-        }
-        return false;
-    }
-    getTypes(service, parent = true) {
-        if (!service) {
-            throw new exceptions_1.InvalidArgument('argument "service" cannot be null or empty');
-        }
-        const name = (0, helpers_js_1.getTypeName)(service);
-        if (this.registry.has(name)) {
-            return this.registry.get(name);
-        }
-        if (this.container.Parent && parent) {
-            return this.container.Parent.getRegisteredTypes(service, parent);
-        }
-        return null;
-    }
-    hasRegistered(service, parent = true) {
-        if (this.registry.has((0, helpers_js_1.getTypeName)(service))) {
-            return true;
-        }
-        else if (parent && this.container.Parent) {
-            return this.container.Parent.hasRegistered(service, parent);
-        }
-        return false;
-    }
-}
-exports.Registry = Registry;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registry = void 0;
+const exceptions_1 = require("@spinajs/exceptions");
+const helpers_js_1 = require("./helpers.js");
+class Registry {
+    constructor(container) {
+        this.container = container;
+        this.registry = new Map();
+    }
+    clear() {
+        this.registry.clear();
+    }
+    unregister(type) {
+        const tname = (0, helpers_js_1.getTypeName)(type);
+        this.registry.forEach((value) => {
+            const index = value.findIndex((x) => (0, helpers_js_1.getTypeName)(x) === tname);
+            if (index !== -1) {
+                value.splice(index, 1);
+            }
+        });
+    }
+    register(name, type) {
+        if (!(0, helpers_js_1.isConstructor)(type) && !(0, helpers_js_1.isFactory)(type) && !(0, helpers_js_1.isObject)(type)) {
+            throw new exceptions_1.InvalidOperation('cannot register type if its not an class or factory function');
+        }
+        else {
+            const tname = (0, helpers_js_1.getTypeName)(name);
+            const value = this.registry.get(tname);
+            if (value) {
+                // factory functions, we always add to registry
+                // its impossible to check for duplicates
+                // all would return 'Function' type
+                if ((0, helpers_js_1.isFactory)(type)) {
+                    value.push(type);
+                }
+                else if (!value.find((v) => (0, helpers_js_1.getTypeName)(v) === (0, helpers_js_1.getTypeName)(type))) {
+                    value.push(type);
+                }
+            }
+            else {
+                this.registry.set(tname, [type]);
+            }
+        }
+    }
+    hasRegisteredType(source, type, parent) {
+        const sourceName = (0, helpers_js_1.getTypeName)(source);
+        const targetName = (0, helpers_js_1.getTypeName)(type);
+        if (this.registry.has(sourceName)) {
+            return this.registry.get(sourceName).find((s) => s.name === targetName) !== undefined;
+        }
+        else if (parent && this.container.Parent) {
+            return this.container.Parent.hasRegisteredType(source, type, parent);
+        }
+        return false;
+    }
+    getTypes(service, parent = true) {
+        if (!service) {
+            throw new exceptions_1.InvalidArgument('argument "service" cannot be null or empty');
+        }
+        const name = (0, helpers_js_1.getTypeName)(service);
+        if (this.registry.has(name)) {
+            return this.registry.get(name);
+        }
+        if (this.container.Parent && parent) {
+            return this.container.Parent.getRegisteredTypes(service, parent);
+        }
+        return null;
+    }
+    hasRegistered(service, parent = true) {
+        if (this.registry.has((0, helpers_js_1.getTypeName)(service))) {
+            return true;
+        }
+        else if (parent && this.container.Parent) {
+            return this.container.Parent.hasRegistered(service, parent);
+        }
+        return false;
+    }
+}
+exports.Registry = Registry;
 //# sourceMappingURL=registry.js.map