inversify 5.1.1 → 6.0.2

package/lib/container/container_module.d.ts

@@ -1,11 +1,11 @@
-import { interfaces } from "../interfaces/interfaces";
-export declare class ContainerModule implements interfaces.ContainerModule {
-    id: number;
-    registry: interfaces.ContainerModuleCallBack;
-    constructor(registry: interfaces.ContainerModuleCallBack);
-}
-export declare class AsyncContainerModule implements interfaces.AsyncContainerModule {
-    id: number;
-    registry: interfaces.AsyncContainerModuleCallBack;
-    constructor(registry: interfaces.AsyncContainerModuleCallBack);
-}
+import { interfaces } from '../interfaces/interfaces';
+export declare class ContainerModule implements interfaces.ContainerModule {
+    id: number;
+    registry: interfaces.ContainerModuleCallBack;
+    constructor(registry: interfaces.ContainerModuleCallBack);
+}
+export declare class AsyncContainerModule implements interfaces.AsyncContainerModule {
+    id: number;
+    registry: interfaces.AsyncContainerModuleCallBack;
+    constructor(registry: interfaces.AsyncContainerModuleCallBack);
+}

package/lib/container/container_module.js

@@ -1,21 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncContainerModule = exports.ContainerModule = void 0;
-var id_1 = require("../utils/id");
-var ContainerModule = (function () {
-    function ContainerModule(registry) {
-        this.id = id_1.id();
-        this.registry = registry;
-    }
-    return ContainerModule;
-}());
-exports.ContainerModule = ContainerModule;
-var AsyncContainerModule = (function () {
-    function AsyncContainerModule(registry) {
-        this.id = id_1.id();
-        this.registry = registry;
-    }
-    return AsyncContainerModule;
-}());
-exports.AsyncContainerModule = AsyncContainerModule;
-//# sourceMappingURL=container_module.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncContainerModule = exports.ContainerModule = void 0;
+var id_1 = require("../utils/id");
+var ContainerModule = (function () {
+    function ContainerModule(registry) {
+        this.id = (0, id_1.id)();
+        this.registry = registry;
+    }
+    return ContainerModule;
+}());
+exports.ContainerModule = ContainerModule;
+var AsyncContainerModule = (function () {
+    function AsyncContainerModule(registry) {
+        this.id = (0, id_1.id)();
+        this.registry = registry;
+    }
+    return AsyncContainerModule;
+}());
+exports.AsyncContainerModule = AsyncContainerModule;

package/lib/container/container_snapshot.d.ts

@@ -1,7 +1,10 @@
-import { interfaces } from "../interfaces/interfaces";
-declare class ContainerSnapshot implements interfaces.ContainerSnapshot {
-    bindings: interfaces.Lookup<interfaces.Binding<any>>;
-    middleware: interfaces.Next | null;
-    static of(bindings: interfaces.Lookup<interfaces.Binding<any>>, middleware: interfaces.Next | null): ContainerSnapshot;
-}
-export { ContainerSnapshot };
+import { interfaces } from '../interfaces/interfaces';
+declare class ContainerSnapshot implements interfaces.ContainerSnapshot {
+    bindings: interfaces.Lookup<interfaces.Binding<unknown>>;
+    activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>;
+    deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>;
+    middleware: interfaces.Next | null;
+    moduleActivationStore: interfaces.ModuleActivationStore;
+    static of(bindings: interfaces.Lookup<interfaces.Binding<unknown>>, middleware: interfaces.Next | null, activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>, deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>, moduleActivationStore: interfaces.ModuleActivationStore): ContainerSnapshot;
+}
+export { ContainerSnapshot };

package/lib/container/container_snapshot.js

@@ -1,16 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerSnapshot = void 0;
-var ContainerSnapshot = (function () {
-    function ContainerSnapshot() {
-    }
-    ContainerSnapshot.of = function (bindings, middleware) {
-        var snapshot = new ContainerSnapshot();
-        snapshot.bindings = bindings;
-        snapshot.middleware = middleware;
-        return snapshot;
-    };
-    return ContainerSnapshot;
-}());
-exports.ContainerSnapshot = ContainerSnapshot;
-//# sourceMappingURL=container_snapshot.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerSnapshot = void 0;
+var ContainerSnapshot = (function () {
+    function ContainerSnapshot() {
+    }
+    ContainerSnapshot.of = function (bindings, middleware, activations, deactivations, moduleActivationStore) {
+        var snapshot = new ContainerSnapshot();
+        snapshot.bindings = bindings;
+        snapshot.middleware = middleware;
+        snapshot.deactivations = deactivations;
+        snapshot.activations = activations;
+        snapshot.moduleActivationStore = moduleActivationStore;
+        return snapshot;
+    };
+    return ContainerSnapshot;
+}());
+exports.ContainerSnapshot = ContainerSnapshot;

package/lib/container/lookup.d.ts

@@ -1,14 +1,16 @@
-import { interfaces } from "../interfaces/interfaces";
-declare class Lookup<T extends interfaces.Clonable<T>> implements interfaces.Lookup<T> {
-    private _map;
-    constructor();
-    getMap(): Map<interfaces.ServiceIdentifier<any>, T[]>;
-    add(serviceIdentifier: interfaces.ServiceIdentifier<any>, value: T): void;
-    get(serviceIdentifier: interfaces.ServiceIdentifier<any>): T[];
-    remove(serviceIdentifier: interfaces.ServiceIdentifier<any>): void;
-    removeByCondition(condition: (item: T) => boolean): void;
-    hasKey(serviceIdentifier: interfaces.ServiceIdentifier<any>): boolean;
-    clone(): interfaces.Lookup<T>;
-    traverse(func: (key: interfaces.ServiceIdentifier<any>, value: T[]) => void): void;
-}
-export { Lookup };
+import { interfaces } from '../interfaces/interfaces';
+declare class Lookup<T> implements interfaces.Lookup<T> {
+    private _map;
+    constructor();
+    getMap(): Map<interfaces.ServiceIdentifier<unknown>, T[]>;
+    add(serviceIdentifier: interfaces.ServiceIdentifier, value: T): void;
+    get(serviceIdentifier: interfaces.ServiceIdentifier): T[];
+    remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
+    removeIntersection(lookup: interfaces.Lookup<T>): void;
+    removeByCondition(condition: (item: T) => boolean): T[];
+    hasKey(serviceIdentifier: interfaces.ServiceIdentifier): boolean;
+    clone(): interfaces.Lookup<T>;
+    traverse(func: (key: interfaces.ServiceIdentifier, value: T[]) => void): void;
+    private _setValue;
+}
+export { Lookup };

package/lib/container/lookup.js

@@ -1,81 +1,126 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lookup = void 0;
-var ERROR_MSGS = require("../constants/error_msgs");
-var Lookup = (function () {
-    function Lookup() {
-        this._map = new Map();
-    }
-    Lookup.prototype.getMap = function () {
-        return this._map;
-    };
-    Lookup.prototype.add = function (serviceIdentifier, value) {
-        if (serviceIdentifier === null || serviceIdentifier === undefined) {
-            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-        }
-        if (value === null || value === undefined) {
-            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-        }
-        var entry = this._map.get(serviceIdentifier);
-        if (entry !== undefined) {
-            entry.push(value);
-            this._map.set(serviceIdentifier, entry);
-        }
-        else {
-            this._map.set(serviceIdentifier, [value]);
-        }
-    };
-    Lookup.prototype.get = function (serviceIdentifier) {
-        if (serviceIdentifier === null || serviceIdentifier === undefined) {
-            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-        }
-        var entry = this._map.get(serviceIdentifier);
-        if (entry !== undefined) {
-            return entry;
-        }
-        else {
-            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
-        }
-    };
-    Lookup.prototype.remove = function (serviceIdentifier) {
-        if (serviceIdentifier === null || serviceIdentifier === undefined) {
-            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-        }
-        if (!this._map.delete(serviceIdentifier)) {
-            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
-        }
-    };
-    Lookup.prototype.removeByCondition = function (condition) {
-        var _this = this;
-        this._map.forEach(function (entries, key) {
-            var updatedEntries = entries.filter(function (entry) { return !condition(entry); });
-            if (updatedEntries.length > 0) {
-                _this._map.set(key, updatedEntries);
-            }
-            else {
-                _this._map.delete(key);
-            }
-        });
-    };
-    Lookup.prototype.hasKey = function (serviceIdentifier) {
-        if (serviceIdentifier === null || serviceIdentifier === undefined) {
-            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-        }
-        return this._map.has(serviceIdentifier);
-    };
-    Lookup.prototype.clone = function () {
-        var copy = new Lookup();
-        this._map.forEach(function (value, key) {
-            value.forEach(function (b) { return copy.add(key, b.clone()); });
-        });
-        return copy;
-    };
-    Lookup.prototype.traverse = function (func) {
-        this._map.forEach(function (value, key) {
-            func(key, value);
-        });
-    };
-    return Lookup;
-}());
-exports.Lookup = Lookup;
-//# sourceMappingURL=lookup.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lookup = void 0;
+var ERROR_MSGS = __importStar(require("../constants/error_msgs"));
+var clonable_1 = require("../utils/clonable");
+var Lookup = (function () {
+    function Lookup() {
+        this._map = new Map();
+    }
+    Lookup.prototype.getMap = function () {
+        return this._map;
+    };
+    Lookup.prototype.add = function (serviceIdentifier, value) {
+        if (serviceIdentifier === null || serviceIdentifier === undefined) {
+            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
+        }
+        if (value === null || value === undefined) {
+            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
+        }
+        var entry = this._map.get(serviceIdentifier);
+        if (entry !== undefined) {
+            entry.push(value);
+        }
+        else {
+            this._map.set(serviceIdentifier, [value]);
+        }
+    };
+    Lookup.prototype.get = function (serviceIdentifier) {
+        if (serviceIdentifier === null || serviceIdentifier === undefined) {
+            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
+        }
+        var entry = this._map.get(serviceIdentifier);
+        if (entry !== undefined) {
+            return entry;
+        }
+        else {
+            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
+        }
+    };
+    Lookup.prototype.remove = function (serviceIdentifier) {
+        if (serviceIdentifier === null || serviceIdentifier === undefined) {
+            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
+        }
+        if (!this._map.delete(serviceIdentifier)) {
+            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
+        }
+    };
+    Lookup.prototype.removeIntersection = function (lookup) {
+        var _this = this;
+        this.traverse(function (serviceIdentifier, value) {
+            var lookupActivations = lookup.hasKey(serviceIdentifier) ? lookup.get(serviceIdentifier) : undefined;
+            if (lookupActivations !== undefined) {
+                var filteredValues = value.filter(function (lookupValue) {
+                    return !lookupActivations.some(function (moduleActivation) { return lookupValue === moduleActivation; });
+                });
+                _this._setValue(serviceIdentifier, filteredValues);
+            }
+        });
+    };
+    Lookup.prototype.removeByCondition = function (condition) {
+        var _this = this;
+        var removals = [];
+        this._map.forEach(function (entries, key) {
+            var updatedEntries = [];
+            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+                var entry = entries_1[_i];
+                var remove = condition(entry);
+                if (remove) {
+                    removals.push(entry);
+                }
+                else {
+                    updatedEntries.push(entry);
+                }
+            }
+            _this._setValue(key, updatedEntries);
+        });
+        return removals;
+    };
+    Lookup.prototype.hasKey = function (serviceIdentifier) {
+        if (serviceIdentifier === null || serviceIdentifier === undefined) {
+            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
+        }
+        return this._map.has(serviceIdentifier);
+    };
+    Lookup.prototype.clone = function () {
+        var copy = new Lookup();
+        this._map.forEach(function (value, key) {
+            value.forEach(function (b) { return copy.add(key, (0, clonable_1.isClonable)(b) ? b.clone() : b); });
+        });
+        return copy;
+    };
+    Lookup.prototype.traverse = function (func) {
+        this._map.forEach(function (value, key) {
+            func(key, value);
+        });
+    };
+    Lookup.prototype._setValue = function (serviceIdentifier, value) {
+        if (value.length > 0) {
+            this._map.set(serviceIdentifier, value);
+        }
+        else {
+            this._map.delete(serviceIdentifier);
+        }
+    };
+    return Lookup;
+}());
+exports.Lookup = Lookup;

package/lib/container/module_activation_store.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from '../interfaces/interfaces';
+export declare class ModuleActivationStore implements interfaces.ModuleActivationStore {
+    private _map;
+    remove(moduleId: number): interfaces.ModuleActivationHandlers;
+    addDeactivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
+    addActivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
+    clone(): interfaces.ModuleActivationStore;
+    private _getModuleActivationHandlers;
+    private _getEmptyHandlersStore;
+}

package/lib/container/module_activation_store.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleActivationStore = void 0;
+var lookup_1 = require("./lookup");
+var ModuleActivationStore = (function () {
+    function ModuleActivationStore() {
+        this._map = new Map();
+    }
+    ModuleActivationStore.prototype.remove = function (moduleId) {
+        if (this._map.has(moduleId)) {
+            var handlers = this._map.get(moduleId);
+            this._map.delete(moduleId);
+            return handlers;
+        }
+        return this._getEmptyHandlersStore();
+    };
+    ModuleActivationStore.prototype.addDeactivation = function (moduleId, serviceIdentifier, onDeactivation) {
+        this._getModuleActivationHandlers(moduleId)
+            .onDeactivations.add(serviceIdentifier, onDeactivation);
+    };
+    ModuleActivationStore.prototype.addActivation = function (moduleId, serviceIdentifier, onActivation) {
+        this._getModuleActivationHandlers(moduleId)
+            .onActivations.add(serviceIdentifier, onActivation);
+    };
+    ModuleActivationStore.prototype.clone = function () {
+        var clone = new ModuleActivationStore();
+        this._map.forEach(function (handlersStore, moduleId) {
+            clone._map.set(moduleId, {
+                onActivations: handlersStore.onActivations.clone(),
+                onDeactivations: handlersStore.onDeactivations.clone(),
+            });
+        });
+        return clone;
+    };
+    ModuleActivationStore.prototype._getModuleActivationHandlers = function (moduleId) {
+        var moduleActivationHandlers = this._map.get(moduleId);
+        if (moduleActivationHandlers === undefined) {
+            moduleActivationHandlers = this._getEmptyHandlersStore();
+            this._map.set(moduleId, moduleActivationHandlers);
+        }
+        return moduleActivationHandlers;
+    };
+    ModuleActivationStore.prototype._getEmptyHandlersStore = function () {
+        var handlersStore = {
+            onActivations: new lookup_1.Lookup(),
+            onDeactivations: new lookup_1.Lookup()
+        };
+        return handlersStore;
+    };
+    return ModuleActivationStore;
+}());
+exports.ModuleActivationStore = ModuleActivationStore;