ts-ioc-container 56.1.0 → 56.2.0

package/cjm/ExecutionContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjm/container/AliasMap.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasMap = void 0;
+class AliasMap {
+    aliasToKeySet = new Map();
+    getKeysByAlias(alias) {
+        return [...(this.aliasToKeySet.get(alias) ?? [])];
+    }
+    setAliasesByKey(key, aliases) {
+        for (const [alias, keySet] of this.aliasToKeySet) {
+            keySet.delete(key);
+            if (keySet.size === 0) {
+                this.aliasToKeySet.delete(alias);
+            }
+        }
+        for (const alias of aliases) {
+            const dependencyKeySet = this.aliasToKeySet.get(alias) ?? new Set();
+            this.aliasToKeySet.set(alias, dependencyKeySet.add(key));
+        }
+    }
+    destroy() {
+        this.aliasToKeySet.clear();
+    }
+}
+exports.AliasMap = AliasMap;

package/cjm/container/Container.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+const EmptyContainer_1 = require("./EmptyContainer");
+const ContainerDisposedError_1 = require("../errors/ContainerDisposedError");
+const MetadataInjector_1 = require("../injector/MetadataInjector");
+const AliasMap_1 = require("./AliasMap");
+const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
+const basic_1 = require("../utils/basic");
+const array_1 = require("../utils/array");
+class Container {
+    isDisposed = false;
+    parent;
+    scopes = [];
+    instances = [];
+    registrations = [];
+    tags;
+    providers = new Map();
+    aliases = new AliasMap_1.AliasMap();
+    injector;
+    onConstructHookList = [];
+    onDisposeHookList = [];
+    constructor(options = {}) {
+        this.injector = options.injector ?? new MetadataInjector_1.MetadataInjector();
+        this.parent = options.parent ?? new EmptyContainer_1.EmptyContainer();
+        this.tags = new Set(options.tags ?? []);
+    }
+    register(key, provider, { aliases = [] } = {}) {
+        this.validateContainer();
+        this.providers.set(key, provider);
+        this.aliases.setAliasesByKey(key, aliases);
+        return this;
+    }
+    resolve(target, { args = [], child = this, lazy } = {}) {
+        this.validateContainer();
+        if (basic_1.Is.constructor(target)) {
+            return this.injector.resolve(this, target, { args, lazy });
+        }
+        const provider = this.providers.get(target);
+        return provider?.hasAccess({ invocationScope: child, providerScope: this, args })
+            ? provider.resolve(this, { args, lazy })
+            : this.parent.resolve(target, { args, child, lazy });
+    }
+    resolveByAlias(alias, { args = [], child = this, lazy, excludedKeys = [] } = {}) {
+        this.validateContainer();
+        const keys = [];
+        const deps = [];
+        for (const key of this.aliases.getKeysByAlias(alias).filter(array_1.Filter.exclude(excludedKeys))) {
+            const provider = this.findProviderByKeyOrFail(key);
+            if (!provider.hasAccess({ invocationScope: child, providerScope: this, args })) {
+                continue;
+            }
+            keys.push(key);
+            deps.push(provider.resolve(this, { args, lazy }));
+        }
+        const parentDeps = this.parent.resolveByAlias(alias, {
+            args,
+            child,
+            lazy,
+            excludedKeys: [...excludedKeys, ...keys],
+        });
+        return [...deps, ...parentDeps];
+    }
+    resolveOneByAlias(alias, { args = [], child = this, lazy } = {}) {
+        this.validateContainer();
+        const [key] = this.aliases.getKeysByAlias(alias);
+        const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
+        return provider?.hasAccess({ invocationScope: child, providerScope: this, args })
+            ? provider.resolve(this, { args, lazy })
+            : this.parent.resolveOneByAlias(alias, { args, child, lazy });
+    }
+    createScope({ tags } = {}) {
+        this.validateContainer();
+        const scope = new Container({ injector: this.injector, parent: this, tags })
+            .addOnConstructHook(...this.onConstructHookList)
+            .addOnDisposeHook(...this.onDisposeHookList);
+        for (const registration of this.getRegistrations()) {
+            registration.applyTo(scope);
+        }
+        this.scopes.push(scope);
+        return scope;
+    }
+    dispose() {
+        this.validateContainer();
+        this.isDisposed = true;
+        while (this.onDisposeHookList.length) {
+            const onDispose = this.onDisposeHookList.shift();
+            onDispose(this);
+        }
+        this.parent.removeScope(this);
+        this.parent = new EmptyContainer_1.EmptyContainer();
+        for (const provider of this.providers.values()) {
+            provider.dispose();
+        }
+        this.providers.clear();
+        this.aliases.destroy();
+        this.instances = [];
+        this.registrations = [];
+        this.onConstructHookList.length = 0;
+    }
+    addRegistration(registration) {
+        this.registrations.push(registration);
+        registration.applyTo(this);
+        return this;
+    }
+    getRegistrations() {
+        return [...this.parent.getRegistrations(), ...this.registrations];
+    }
+    hasRegistration(key) {
+        return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
+    }
+    addOnConstructHook(...hooks) {
+        this.onConstructHookList.push(...hooks);
+        return this;
+    }
+    addOnDisposeHook(...hooks) {
+        this.onDisposeHookList.push(...hooks);
+        return this;
+    }
+    addInstance(instance) {
+        this.instances.push(instance);
+        for (const onConstruct of this.onConstructHookList) {
+            onConstruct(instance, this);
+        }
+    }
+    getScopes() {
+        return [...this.scopes];
+    }
+    hasInstance(instance) {
+        return this.instances.includes(instance);
+    }
+    getScopeByInstanceOrFail(instance) {
+        this.validateContainer();
+        if (this.hasInstance(instance)) {
+            return this;
+        }
+        return this.parent.getScopeByInstanceOrFail(instance);
+    }
+    removeScope(child) {
+        this.scopes = this.scopes.filter((s) => s !== child);
+    }
+    useModule(module) {
+        module.applyTo(this);
+        return this;
+    }
+    getParent() {
+        return this.parent;
+    }
+    getInstances(cascade = false) {
+        if (!cascade) {
+            return [...this.instances];
+        }
+        return [...this.instances, ...this.scopes.flatMap((s) => s.getInstances(true))];
+    }
+    hasTag(tag) {
+        return this.tags.has(tag);
+    }
+    addTags(...tags) {
+        for (const tag of tags) {
+            this.tags.add(tag);
+        }
+    }
+    validateContainer() {
+        if (this.isDisposed) {
+            throw new ContainerDisposedError_1.ContainerDisposedError('Container is already disposed');
+        }
+    }
+    findProviderByKeyOrFail(key) {
+        if (!this.providers.has(key)) {
+            throw new DependencyNotFoundError_1.DependencyNotFoundError(`Provider ${key.toString()} does not exist`);
+        }
+        return this.providers.get(key);
+    }
+}
+exports.Container = Container;

package/cjm/container/EmptyContainer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyContainer = void 0;
+const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError");
+const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
+const ContainerNotFoundError_1 = require("../errors/ContainerNotFoundError");
+class EmptyContainer {
+    get isDisposed() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    addInstance(instance) { }
+    getParent() {
+        return undefined;
+    }
+    getScopes() {
+        return [];
+    }
+    getScopeByInstanceOrFail(instance) {
+        throw new ContainerNotFoundError_1.ContainerNotFoundError('Cannot find scope for the given instance');
+    }
+    getInstances() {
+        return [];
+    }
+    hasInstance(instance) {
+        return false;
+    }
+    createScope() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    dispose() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    register(key, value) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    hasTag(tag) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    addTags(...tags) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    getRegistrations() {
+        return [];
+    }
+    hasRegistration(key) {
+        return false;
+    }
+    removeScope() { }
+    useModule(module) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    addRegistration(registration) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    resolve(key, options) {
+        throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find ${key.toString()}`);
+    }
+    resolveByAlias(alias, options) {
+        return [];
+    }
+    resolveOneByAlias(alias, options) {
+        throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
+    }
+    addOnDisposeHook(...hooks) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    addOnConstructHook(...hooks) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+}
+exports.EmptyContainer = EmptyContainer;

package/cjm/container/IContainer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDependencyKey = isDependencyKey;
+function isDependencyKey(target) {
+    return typeof target === 'symbol' || typeof target === 'string';
+}

package/cjm/errors/CannonSingletonApplyTwiceError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CannonSingletonApplyTwiceError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class CannonSingletonApplyTwiceError extends ContainerError_1.ContainerError {
+    name = 'CannonSingletonApplyTwiceError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CannonSingletonApplyTwiceError.prototype);
+    }
+    static assert(isTrue, failMessage) {
+        if (!isTrue) {
+            throw new CannonSingletonApplyTwiceError(failMessage);
+        }
+    }
+}
+exports.CannonSingletonApplyTwiceError = CannonSingletonApplyTwiceError;

package/cjm/errors/ContainerDisposedError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerDisposedError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class ContainerDisposedError extends ContainerError_1.ContainerError {
+    name = 'ContainerDisposedError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ContainerDisposedError.prototype);
+    }
+}
+exports.ContainerDisposedError = ContainerDisposedError;

package/cjm/errors/ContainerError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerError = void 0;
+class ContainerError extends Error {
+    name = 'ContainerError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ContainerError.prototype);
+    }
+}
+exports.ContainerError = ContainerError;

package/cjm/errors/ContainerNotFoundError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerNotFoundError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class ContainerNotFoundError extends ContainerError_1.ContainerError {
+    name = 'ContainerNotFoundError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ContainerNotFoundError.prototype);
+    }
+}
+exports.ContainerNotFoundError = ContainerNotFoundError;

package/cjm/errors/DependencyMissingKeyError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyMissingKeyError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class DependencyMissingKeyError extends ContainerError_1.ContainerError {
+    name = 'DependencyMissingKeyError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, DependencyMissingKeyError.prototype);
+    }
+}
+exports.DependencyMissingKeyError = DependencyMissingKeyError;

package/cjm/errors/DependencyNotFoundError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyNotFoundError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class DependencyNotFoundError extends ContainerError_1.ContainerError {
+    name = 'DependencyNotFoundError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, DependencyNotFoundError.prototype);
+    }
+}
+exports.DependencyNotFoundError = DependencyNotFoundError;

package/cjm/errors/MethodNotImplementedError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodNotImplementedError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class MethodNotImplementedError extends ContainerError_1.ContainerError {
+    name = 'MethodNotImplementedError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, MethodNotImplementedError.prototype);
+    }
+}
+exports.MethodNotImplementedError = MethodNotImplementedError;

package/cjm/errors/ProviderDisposedError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderDisposedError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class ProviderDisposedError extends ContainerError_1.ContainerError {
+    name = 'ProviderDisposedError';
+    static assert(isTrue, failMessage) {
+        if (!isTrue) {
+            throw new ProviderDisposedError(failMessage);
+        }
+    }
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ProviderDisposedError.prototype);
+    }
+}
+exports.ProviderDisposedError = ProviderDisposedError;

package/cjm/errors/UnexpectedHookResultError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnexpectedHookResultError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class UnexpectedHookResultError extends ContainerError_1.ContainerError {
+    name = 'UnexpectedHookResultError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, UnexpectedHookResultError.prototype);
+    }
+}
+exports.UnexpectedHookResultError = UnexpectedHookResultError;

package/cjm/errors/UnsupportedTokenTypeError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedTokenTypeError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class UnsupportedTokenTypeError extends ContainerError_1.ContainerError {
+    name = 'UnsupportedTokenTypeError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, UnsupportedTokenTypeError.prototype);
+    }
+}
+exports.UnsupportedTokenTypeError = UnsupportedTokenTypeError;

package/cjm/hooks/HookContext.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHookContextFactory = exports.createHookContext = exports.HookContext = void 0;
+const proxy_1 = require("../utils/proxy");
+const MetadataInjector_1 = require("../injector/MetadataInjector");
+class HookContext {
+    scope;
+    methodName;
+    instance;
+    initialArgs = [];
+    constructor(instance, scope, methodName) {
+        this.scope = scope;
+        this.methodName = methodName;
+        this.instance = (0, proxy_1.isProxy)(instance) ? (0, proxy_1.getProxyTarget)(instance) : instance;
+    }
+    resolveArgs(...args) {
+        return (0, MetadataInjector_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, {
+            args: [...this.initialArgs, ...args],
+        });
+    }
+    invokeMethod({ args = this.resolveArgs() } = {}) {
+        return this.instance[this.methodName](...args);
+    }
+    setProperty(fn) {
+        this.instance[this.methodName] = fn.resolve(this.scope);
+    }
+    getProperty() {
+        return this.instance[this.methodName];
+    }
+    setInitialArgs(...args) {
+        this.initialArgs = args;
+        return this;
+    }
+    getInitialArgs() {
+        return this.initialArgs;
+    }
+}
+exports.HookContext = HookContext;
+const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
+exports.createHookContext = createHookContext;
+const createHookContextFactory = ({ args = [] } = {}) => (Target, scope, methodName) => (0, exports.createHookContext)(Target, scope, methodName).setInitialArgs(...args);
+exports.createHookContextFactory = createHookContextFactory;

package/cjm/hooks/HooksRunner.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HooksRunner = void 0;
+const HookContext_1 = require("./HookContext");
+const hook_1 = require("./hook");
+const UnexpectedHookResultError_1 = require("../errors/UnexpectedHookResultError");
+const promise_1 = require("../utils/promise");
+class HooksRunner {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    hasHooks(target) {
+        return (0, hook_1.hasHooks)(target, this.key);
+    }
+    execute(target, { scope, createContext = HookContext_1.createHookContext, mapContext = (context) => context, predicate = () => true, }) {
+        const hooks = Array.from((0, hook_1.getHooks)(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
+        const runMethodHooks = (methodName, executions) => {
+            const context = mapContext(createContext(target, scope, methodName));
+            for (const execute of executions) {
+                const result = execute(context);
+                if (result instanceof Promise) {
+                    throw new UnexpectedHookResultError_1.UnexpectedHookResultError(`Hook ${methodName} returned a promise, use runHooksAsync instead`);
+                }
+            }
+        };
+        for (const [methodName, executions] of hooks) {
+            runMethodHooks(methodName, executions.map(hook_1.toHookFn));
+        }
+    }
+    async executeAsync(target, { scope, createContext = HookContext_1.createHookContext, mapContext = (context) => context, predicate = () => true, }) {
+        const hooks = Array.from((0, hook_1.getHooks)(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
+        const runMethodHooks = async (methodName, executions) => {
+            const context = mapContext(createContext(target, scope, methodName));
+            for (const execute of executions) {
+                await (0, promise_1.promisify)(execute(context));
+            }
+        };
+        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(hook_1.toHookFn))));
+    }
+}
+exports.HooksRunner = HooksRunner;

package/cjm/hooks/hook.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hook = exports.toHookFn = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = void 0;
+exports.getHooks = getHooks;
+exports.hasHooks = hasHooks;
+const basic_1 = require("../utils/basic");
+const proxy_1 = require("../utils/proxy");
+const appendHooks = (...fns) => (...prev) => [...prev, ...fns];
+exports.appendHooks = appendHooks;
+const prependHooks = (...fns) => (...prev) => [...fns, ...prev];
+exports.prependHooks = prependHooks;
+exports.append = exports.appendHooks;
+exports.prepend = exports.prependHooks;
+const isHookClassConstructor = (execute) => {
+    return basic_1.Is.constructor(execute) && execute.prototype.execute;
+};
+const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolve(execute).execute(context) : execute;
+exports.toHookFn = toHookFn;
+const getReflectionTarget = (target) => {
+    return (0, proxy_1.isProxy)(target) ? (0, proxy_1.getProxyTarget)(target) : target;
+};
+const getConstructorChain = (ctor) => {
+    const chain = [];
+    let current = ctor;
+    while (typeof current === 'function' && current !== Function.prototype) {
+        chain.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    return chain;
+};
+function getHooks(target, key) {
+    const reflectionTarget = getReflectionTarget(target);
+    const merged = new Map();
+    for (const ctor of getConstructorChain(reflectionTarget.constructor).reverse()) {
+        const ownHooks = Reflect.getOwnMetadata(key, ctor);
+        if (ownHooks) {
+            for (const [methodName, fns] of ownHooks) {
+                merged.set(methodName, fns);
+            }
+        }
+    }
+    return merged;
+}
+function hasHooks(target, key) {
+    const reflectionTarget = getReflectionTarget(target);
+    return getConstructorChain(reflectionTarget.constructor).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
+}
+const hook = (key, mapFn) => (target, propertyKey) => {
+    const hooks = Reflect.hasOwnMetadata(key, target.constructor)
+        ? Reflect.getOwnMetadata(key, target.constructor)
+        : new Map();
+    hooks.set(propertyKey, mapFn(...(hooks.get(propertyKey) ?? [])));
+    Reflect.defineMetadata(key, hooks, target.constructor);
+};
+exports.hook = hook;

package/cjm/hooks/injectProp.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectProp = void 0;
+const toToken_1 = require("../token/toToken");
+const injectProp = (fn) => (context) => context.setProperty((0, toToken_1.toToken)(fn));
+exports.injectProp = injectProp;

package/cjm/hooks/onConstruct.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = void 0;
+const hook_1 = require("./hook");
+const HooksRunner_1 = require("./HooksRunner");
+exports.onConstructHooksRunner = new HooksRunner_1.HooksRunner('onConstruct');
+const onConstruct = (...fns) => (0, hook_1.hook)('onConstruct', (0, hook_1.prependHooks)(...fns));
+exports.onConstruct = onConstruct;
+class AddOnConstructHookModule {
+    onException;
+    constructor(onException) {
+        this.onException = onException;
+    }
+    applyTo(container) {
+        container.addOnConstructHook((instance, scope) => {
+            try {
+                exports.onConstructHooksRunner.execute(instance, { scope });
+            }
+            catch (ex) {
+                if (!this.onException) {
+                    throw ex;
+                }
+                this.onException(ex, { scope });
+            }
+        });
+    }
+}
+exports.AddOnConstructHookModule = AddOnConstructHookModule;

package/cjm/hooks/onConstructAsync.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddOnConstructAsyncHookModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = void 0;
+const hook_1 = require("./hook");
+const HooksRunner_1 = require("./HooksRunner");
+exports.onConstructAsyncHooksRunner = new HooksRunner_1.HooksRunner('onConstructAsync');
+const onConstructAsync = (...fns) => (0, hook_1.hook)('onConstructAsync', (0, hook_1.prependHooks)(...fns));
+exports.onConstructAsync = onConstructAsync;
+class AddOnConstructAsyncHookModule {
+    onException;
+    constructor(onException) {
+        this.onException = onException;
+    }
+    applyTo(container) {
+        container.addOnConstructHook((instance, scope) => {
+            if (!exports.onConstructAsyncHooksRunner.hasHooks(instance)) {
+                return;
+            }
+            exports.onConstructAsyncHooksRunner.executeAsync(instance, { scope }).catch((ex) => {
+                if (!this.onException) {
+                    throw ex;
+                }
+                this.onException(ex, { scope });
+            });
+        });
+    }
+}
+exports.AddOnConstructAsyncHookModule = AddOnConstructAsyncHookModule;

package/cjm/hooks/onContainerDisposed.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddOnDisposeHookModule = exports.onContainerDisposed = exports.onContainerDisposedHooksRunner = void 0;
+const hook_1 = require("./hook");
+const HooksRunner_1 = require("./HooksRunner");
+exports.onContainerDisposedHooksRunner = new HooksRunner_1.HooksRunner('onContainerDisposed');
+const onContainerDisposed = (...fns) => (0, hook_1.hook)('onContainerDisposed', (0, hook_1.prependHooks)(...fns));
+exports.onContainerDisposed = onContainerDisposed;
+class AddOnDisposeHookModule {
+    applyTo(container) {
+        container.addOnDisposeHook((scope) => {
+            for (const instance of scope.getInstances()) {
+                exports.onContainerDisposedHooksRunner.execute(instance, { scope });
+            }
+        });
+    }
+}
+exports.AddOnDisposeHookModule = AddOnDisposeHookModule;