@spinajs/di 2.0.180 → 2.0.181

package/lib/cjs/array.d.ts

@@ -1,11 +1,11 @@
-import { Class } from './types.js';
-declare global {
-    interface ArrayConstructor {
-        ofType<T>(type: Class<T> | string): TypedArray<T>;
-    }
-}
-export declare class TypedArray<R> extends Array<R> {
-    Type: Class<R> | string;
-    constructor(Type: Class<R> | string);
-}
+import { Class } from './types.js';
+declare global {
+    interface ArrayConstructor {
+        ofType<T>(type: Class<T> | string): TypedArray<T>;
+    }
+}
+export declare class TypedArray<R> extends Array<R> {
+    Type: Class<R> | string;
+    constructor(Type: Class<R> | string);
+}
 //# sourceMappingURL=array.d.ts.map

package/lib/cjs/array.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedArray = void 0;
-class TypedArray extends Array {
-    constructor(Type) {
-        super();
-        this.Type = Type;
-    }
-}
-exports.TypedArray = TypedArray;
-Array.ofType = function (type) {
-    return new TypedArray(type);
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedArray = void 0;
+class TypedArray extends Array {
+    constructor(Type) {
+        super();
+        this.Type = Type;
+    }
+}
+exports.TypedArray = TypedArray;
+Array.ofType = function (type) {
+    return new TypedArray(type);
+};
 //# sourceMappingURL=array.js.map

package/lib/cjs/binder.d.ts

@@ -1,40 +1,40 @@
-import { IBind, IContainer, ResolvableObject } from './interfaces.js';
-import { Class, Factory } from './types.js';
-export declare class Binder<T> implements IBind {
-    private implementation;
-    private container;
-    private isFactory;
-    private isConstructor;
-    constructor(implementation: Class<T> | Factory<T> | ResolvableObject, container: IContainer);
-    as<T>(type: string | Class<T>): 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: string, override?: boolean): 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, key: string): 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(): this;
-    /**
-     * Mark type as SingleInstance resolve strategy.
-     * @returns this
-     */
-    singleInstance(): this;
-}
+import { IBind, IContainer, ResolvableObject } from './interfaces.js';
+import { Class, Factory } from './types.js';
+export declare class Binder<T> implements IBind {
+    private implementation;
+    private container;
+    private isFactory;
+    private isConstructor;
+    constructor(implementation: Class<T> | Factory<T> | ResolvableObject, container: IContainer);
+    as<T>(type: string | Class<T>): 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: string, override?: boolean): 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, key: string): 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(): this;
+    /**
+     * Mark type as SingleInstance resolve strategy.
+     * @returns this
+     */
+    singleInstance(): this;
+}
 //# sourceMappingURL=binder.d.ts.map

package/lib/cjs/binder.js

@@ -1,97 +1,97 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Binder = void 0;
-const exceptions_js_1 = require("./exceptions.js");
-const enums_js_1 = require("./enums.js");
-const helpers_js_1 = require("./helpers.js");
-const index_js_1 = require("./index.js");
-class Binder {
-    constructor(implementation, container) {
-        this.implementation = implementation;
-        this.container = container;
-        this.isFactory = (0, helpers_js_1.isFactory)(implementation);
-        this.isConstructor = (0, helpers_js_1.isConstructor)(implementation);
-    }
-    as(type) {
-        this.container.Registry.register(type, this.implementation);
-        const iType = (0, helpers_js_1.getTypeName)(this.implementation);
-        const tType = (0, helpers_js_1.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 = (0, helpers_js_1.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 = (0, helpers_js_1.getTypeName)(this.implementation);
-        const tType = (0, helpers_js_1.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 exceptions_js_1.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 = (0, helpers_js_1.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 exceptions_js_1.BindException('Cannot bind factory function as singleton.');
-        }
-        else {
-            const descriptor = index_js_1.DI.RootContainer.extractDescriptor(this.implementation);
-            descriptor.resolver = enums_js_1.ResolveType.Singleton;
-        }
-        return this;
-    }
-}
-exports.Binder = Binder;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Binder = void 0;
+const exceptions_js_1 = require("./exceptions.js");
+const enums_js_1 = require("./enums.js");
+const helpers_js_1 = require("./helpers.js");
+const index_js_1 = require("./index.js");
+class Binder {
+    constructor(implementation, container) {
+        this.implementation = implementation;
+        this.container = container;
+        this.isFactory = (0, helpers_js_1.isFactory)(implementation);
+        this.isConstructor = (0, helpers_js_1.isConstructor)(implementation);
+    }
+    as(type) {
+        this.container.Registry.register(type, this.implementation);
+        const iType = (0, helpers_js_1.getTypeName)(this.implementation);
+        const tType = (0, helpers_js_1.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 = (0, helpers_js_1.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 = (0, helpers_js_1.getTypeName)(this.implementation);
+        const tType = (0, helpers_js_1.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 exceptions_js_1.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 = (0, helpers_js_1.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 exceptions_js_1.BindException('Cannot bind factory function as singleton.');
+        }
+        else {
+            const descriptor = index_js_1.DI.RootContainer.extractDescriptor(this.implementation);
+            descriptor.resolver = enums_js_1.ResolveType.Singleton;
+        }
+        return this;
+    }
+}
+exports.Binder = Binder;
 //# sourceMappingURL=binder.js.map

package/lib/cjs/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/cjs/container-cache.js

@@ -1,64 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerCache = void 0;
-const helpers_js_1 = require("./helpers.js");
-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((0, helpers_js_1.getTypeName)(key));
-        }
-        else if (parent && this.container.Parent) {
-            this.container.Parent.uncache(key);
-        }
-    }
-    add(key, instance) {
-        const tName = (0, helpers_js_1.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((0, helpers_js_1.getTypeName)(key))) {
-            return true;
-        }
-        if (parent && this.container.Parent) {
-            return this.container.Parent.Cache.has(key, parent);
-        }
-        return false;
-    }
-    get(key, parent) {
-        const tName = (0, helpers_js_1.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);
-    }
-}
-exports.ContainerCache = ContainerCache;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerCache = void 0;
+const helpers_js_1 = require("./helpers.js");
+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((0, helpers_js_1.getTypeName)(key));
+        }
+        else if (parent && this.container.Parent) {
+            this.container.Parent.uncache(key);
+        }
+    }
+    add(key, instance) {
+        const tName = (0, helpers_js_1.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((0, helpers_js_1.getTypeName)(key))) {
+            return true;
+        }
+        if (parent && this.container.Parent) {
+            return this.container.Parent.Cache.has(key, parent);
+        }
+        return false;
+    }
+    get(key, parent) {
+        const tName = (0, helpers_js_1.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);
+    }
+}
+exports.ContainerCache = ContainerCache;
 //# sourceMappingURL=container-cache.js.map