ts-ioc-container 32.10.0 → 32.11.0

package/README.md

@@ -785,7 +785,7 @@ import {
   Registration as R,
   scope,
 } from 'ts-ioc-container';
-import { constant } from '../../lib/utils.ts';
+import { constant } from '../../lib/utils';
 
 describe('alias', () => {
   const IMiddlewareKey = 'IMiddleware';
@@ -1145,23 +1145,23 @@ import 'reflect-metadata';
 import {
   constructor,
   Container,
-  key,
   hook,
   IContainer,
   IInjector,
+  InjectOptions,
+  key,
   MetadataInjector,
-  Registration as R,
   register,
-  executeHooks,
+  Registration as R,
+  runHooks,
 } from 'ts-ioc-container';
-import { InjectOptions } from '../lib/injector/IInjector.ts';
 
 class MyInjector implements IInjector {
   private injector = new MetadataInjector();
 
   resolve<T>(container: IContainer, value: constructor<T>, options: InjectOptions): T {
     const instance = this.injector.resolve(container, value, options);
-    executeHooks(instance as object, 'onConstruct', { scope: container });
+    void runHooks(instance as object, 'onConstruct', { scope: container, handleError: jest.fn() });
     return instance;
   }
 }
@@ -1170,7 +1170,9 @@ class MyInjector implements IInjector {
 class Logger {
   isReady = false;
 
-  @hook('onConstruct', (context) => context.invokeMethod({ args: [] })) // <--- or extract it to @onConstruct
+  @hook('onConstruct', (context) => {
+    context.invokeMethod({ args: [] });
+  }) // <--- or extract it to @onConstruct
   initialize() {
     this.isReady = true;
   }
@@ -1196,17 +1198,17 @@ describe('onConstruct', function () {
 ```typescript
 import 'reflect-metadata';
 import {
-  singleton,
   by,
   Container,
-  key,
   hook,
   inject,
-  provider,
-  Registration as R,
+  key,
   MetadataInjector,
+  provider,
   register,
-  executeHooks,
+  Registration as R,
+  runHooks,
+  singleton,
 } from 'ts-ioc-container';
 
 @register(key('logsRepo'))
@@ -1237,7 +1239,9 @@ class Logger {
     return this.messages.length;
   }
 
-  @hook('onDispose', (c) => c.invokeMethod({ args: [] })) // <--- or extract it to @onDispose
+  @hook('onDispose', (c) => {
+    c.invokeMethod({ args: [] });
+  }) // <--- or extract it to @onDispose
   async save(): Promise<void> {
     this.logsRepo.saveLogs(this.messages);
   }
@@ -1251,7 +1255,7 @@ describe('onDispose', function () {
     logger.log('Hello');
 
     for (const instance of container.getInstances()) {
-      executeHooks(instance as object, 'onDispose', { scope: container });
+      void runHooks(instance as object, 'onDispose', { scope: container, handleError: jest.fn() });
     }
 
     expect(container.resolve<LogsRepo>('logsRepo').savedLogs.join(',')).toBe('Hello,world');
@@ -1263,7 +1267,7 @@ describe('onDispose', function () {
 ### Inject property
 
 ```typescript
-import { by, Container, executeHooks, hook, injectProp, MetadataInjector, Registration } from 'ts-ioc-container';
+import { by, Container, hook, injectProp, MetadataInjector, Registration, runHooks } from 'ts-ioc-container';
 
 describe('inject property', () => {
   it('should inject property', () => {
@@ -1275,7 +1279,7 @@ describe('inject property', () => {
 
     const container = new Container(new MetadataInjector()).add(Registration.fromValue(expected).to('greeting'));
     const app = container.resolve(App);
-    executeHooks(app, 'onInit', { scope: container });
+    runHooks(app as object, 'onInit', { scope: container, handleError: jest.fn() });
 
     expect(app.greeting).toBe(expected);
   });
@@ -1286,7 +1290,7 @@ describe('inject property', () => {
 ### Inject method
     
 ```typescript
-import { by, Container, executeHooks, hook, inject, invokeExecution, MetadataInjector, Registration } from 'ts-ioc-container';
+import { by, Container, runHooks, hook, inject, invokeExecution, MetadataInjector, Registration } from 'ts-ioc-container';
 
 describe('inject method', () => {
   const sleep = (number: number) => new Promise((resolve) => setTimeout(resolve, number));
@@ -1304,7 +1308,7 @@ describe('inject method', () => {
 
     const container = new Container(new MetadataInjector()).add(Registration.fromValue(expected).to('greeting'));
     const app = container.resolve(App);
-    await executeHooks(app, 'onInit', { scope: container, handleError: jest.fn() });
+    await runHooks(app, 'onInit', { scope: container, handleError: jest.fn() });
 
     expect(app.greeting).toBe(expected);
   });
@@ -1324,7 +1328,7 @@ describe('inject method', () => {
       .add(Registration.fromFn(() => sleep(25).then(() => 'world')).to('person'));
 
     const app = container.resolve(App);
-    await executeHooks(app, 'onInit', { scope: container, handleError: jest.fn() });
+    await runHooks(app, 'onInit', { scope: container, handleError: jest.fn() });
 
     expect(app.greeting).toBe('Hello,world');
   });

package/cjm/hooks/HookContext.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hookMetaKey = exports.createHookContext = exports.HookContext = void 0;
+const inject_1 = require("../injector/inject");
+class HookContext {
+    constructor(instance, scope, methodName) {
+        this.instance = instance;
+        this.scope = scope;
+        this.methodName = methodName;
+    }
+    resolveArgs(...args) {
+        return (0, inject_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, ...args);
+    }
+    invokeMethod({ args = this.resolveArgs() }) {
+        // @ts-ignore
+        return this.instance[this.methodName](...args);
+    }
+    injectProperty(fn) {
+        // @ts-ignore
+        this.instance[this.methodName] = fn(this.scope);
+    }
+}
+exports.HookContext = HookContext;
+const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
+exports.createHookContext = createHookContext;
+const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
+exports.hookMetaKey = hookMetaKey;

package/cjm/hooks/hook.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.invokeExecution = exports.injectProp = exports.executeHooks = exports.hasHooks = exports.getHooks = exports.hook = void 0;
-const ExecutionContext_1 = require("./ExecutionContext");
+exports.executeHooks = exports.invokeExecution = exports.injectProp = exports.runHooks = exports.hasHooks = exports.getHooks = exports.hook = void 0;
+const HookContext_1 = require("./HookContext");
 const utils_1 = require("../utils");
 const hook = (key, ...fns) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(key, target.constructor)
@@ -19,13 +19,12 @@ function hasHooks(target, key) {
     return Reflect.hasMetadata(key, target.constructor);
 }
 exports.hasHooks = hasHooks;
-const executeHooks = (target, key, { scope, decorateContext = (c) => c, handleError, }) => {
+const runHooks = (target, key, { scope, createContext = HookContext_1.createHookContext, handleError, }) => {
     const hooks = Array.from(getHooks(target, key).entries());
-    const createContext = (methodName) => decorateContext(new ExecutionContext_1.ExecutionContext(target, methodName, scope));
     const runExecution = (execute, context) => (0, utils_1.promisify)(execute(context)).catch((e) => handleError(e, scope));
-    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(methodName)))));
+    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(target, scope, methodName)))));
 };
-exports.executeHooks = executeHooks;
+exports.runHooks = runHooks;
 const injectProp = (fn) => (context) => context.injectProperty(fn);
 exports.injectProp = injectProp;
 const invokeExecution = ({ handleResult }) => async (context) => {
@@ -33,3 +32,8 @@ const invokeExecution = ({ handleResult }) => async (context) => {
     return handleResult(context.invokeMethod({ args }), context);
 };
 exports.invokeExecution = invokeExecution;
+/**
+ * @deprecated Use `runHooks` instead
+ * @TODO: Remove in v33
+ */
+exports.executeHooks = exports.runHooks;

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.byAliases = exports.byAlias = exports.IMemoKey = exports.by = exports.ExecutionContext = exports.invokeExecution = exports.injectProp = exports.executeHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.getInjectFns = exports.resolveArgs = exports.inject = exports.MetadataInjector = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.byAliases = exports.byAlias = exports.IMemoKey = exports.by = exports.HookContext = exports.invokeExecution = exports.injectProp = exports.runHooks = exports.executeHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -10,11 +10,12 @@ var EmptyContainer_1 = require("./container/EmptyContainer");
 Object.defineProperty(exports, "EmptyContainer", { enumerable: true, get: function () { return EmptyContainer_1.EmptyContainer; } });
 var AutoMockedContainer_1 = require("./container/AutoMockedContainer");
 Object.defineProperty(exports, "AutoMockedContainer", { enumerable: true, get: function () { return AutoMockedContainer_1.AutoMockedContainer; } });
+// Injectors
+var inject_1 = require("./injector/inject");
+Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return inject_1.inject; } });
+Object.defineProperty(exports, "resolveArgs", { enumerable: true, get: function () { return inject_1.resolveArgs; } });
 var MetadataInjector_1 = require("./injector/MetadataInjector");
 Object.defineProperty(exports, "MetadataInjector", { enumerable: true, get: function () { return MetadataInjector_1.MetadataInjector; } });
-Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return MetadataInjector_1.inject; } });
-Object.defineProperty(exports, "resolveArgs", { enumerable: true, get: function () { return MetadataInjector_1.resolveArgs; } });
-Object.defineProperty(exports, "getInjectFns", { enumerable: true, get: function () { return MetadataInjector_1.getInjectFns; } });
 var SimpleInjector_1 = require("./injector/SimpleInjector");
 Object.defineProperty(exports, "SimpleInjector", { enumerable: true, get: function () { return SimpleInjector_1.SimpleInjector; } });
 var ProxyInjector_1 = require("./injector/ProxyInjector");
@@ -57,10 +58,11 @@ Object.defineProperty(exports, "getHooks", { enumerable: true, get: function ()
 Object.defineProperty(exports, "hook", { enumerable: true, get: function () { return hook_1.hook; } });
 Object.defineProperty(exports, "hasHooks", { enumerable: true, get: function () { return hook_1.hasHooks; } });
 Object.defineProperty(exports, "executeHooks", { enumerable: true, get: function () { return hook_1.executeHooks; } });
+Object.defineProperty(exports, "runHooks", { enumerable: true, get: function () { return hook_1.runHooks; } });
 Object.defineProperty(exports, "injectProp", { enumerable: true, get: function () { return hook_1.injectProp; } });
 Object.defineProperty(exports, "invokeExecution", { enumerable: true, get: function () { return hook_1.invokeExecution; } });
-var ExecutionContext_1 = require("./hooks/ExecutionContext");
-Object.defineProperty(exports, "ExecutionContext", { enumerable: true, get: function () { return ExecutionContext_1.ExecutionContext; } });
+var HookContext_1 = require("./hooks/HookContext");
+Object.defineProperty(exports, "HookContext", { enumerable: true, get: function () { return HookContext_1.HookContext; } });
 // Others
 var by_1 = require("./by");
 Object.defineProperty(exports, "by", { enumerable: true, get: function () { return by_1.by; } });

package/cjm/injector/MetadataInjector.js

@@ -1,27 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.getInjectFns = void 0;
-const utils_1 = require("../utils");
-const metadata_1 = require("../metadata");
-const METADATA_KEY = 'inject';
-const getInjectFns = (Target, methodName) => (0, metadata_1.getParameterMetadata)(metaKey(methodName), Target);
-exports.getInjectFns = getInjectFns;
-const metaKey = (methodName = 'constructor') => `${METADATA_KEY}:${methodName}`;
-function isInstance(target) {
-    return Object.prototype.hasOwnProperty.call(target, 'constructor');
-}
-const inject = (fn) => (target, propertyKey, parameterIndex) => {
-    (0, metadata_1.setParameterMetadata)(metaKey(propertyKey), fn)(isInstance(target) ? target.constructor : target, propertyKey, parameterIndex);
-};
-exports.inject = inject;
-const resolveArgs = (Target, methodName) => {
-    const argsFns = (0, exports.getInjectFns)(Target, methodName);
-    return (scope, ...deps) => (0, utils_1.fillEmptyIndexes)(argsFns, deps.map(utils_1.constant)).map((fn) => fn(scope));
-};
-exports.resolveArgs = resolveArgs;
+exports.MetadataInjector = void 0;
+const inject_1 = require("./inject");
 class MetadataInjector {
-    resolve(container, Target, { args: deps }) {
-        const args = (0, exports.resolveArgs)(Target)(container, ...deps);
+    resolve(scope, Target, { args: deps }) {
+        const args = (0, inject_1.resolveArgs)(Target)(scope, ...deps);
         return new Target(...args);
     }
 }

package/cjm/injector/inject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveArgs = exports.inject = void 0;
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const HookContext_1 = require("../hooks/HookContext");
+const inject = (fn) => (target, propertyKey, parameterIndex) => {
+    (0, metadata_1.setParameterMetadata)((0, HookContext_1.hookMetaKey)(propertyKey), fn)((0, utils_1.isInstance)(target) ? target.constructor : target, propertyKey, parameterIndex);
+};
+exports.inject = inject;
+const resolveArgs = (Target, methodName) => {
+    const argsFns = getInjectFns(Target, methodName);
+    return (scope, ...deps) => (0, utils_1.fillEmptyIndexes)(argsFns, deps.map(utils_1.constant)).map((fn) => fn(scope));
+};
+exports.resolveArgs = resolveArgs;
+const getInjectFns = (Target, methodName) => (0, metadata_1.getParameterMetadata)((0, HookContext_1.hookMetaKey)(methodName), Target);

package/cjm/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promisify = exports.lazyProxy = exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
+exports.isInstance = exports.promisify = exports.lazyProxy = exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
 const pipe = (...mappers) => (value) => mappers.reduce((acc, current) => current(acc), value);
 exports.pipe = pipe;
 function fillEmptyIndexes(baseArr, insertArr) {
@@ -31,3 +31,7 @@ function lazyProxy(resolveInstance) {
 exports.lazyProxy = lazyProxy;
 const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));
 exports.promisify = promisify;
+function isInstance(target) {
+    return Object.prototype.hasOwnProperty.call(target, 'constructor');
+}
+exports.isInstance = isInstance;

package/esm/hooks/{ExecutionContext.js → HookContext.js}

@@ -1,9 +1,9 @@
-import { resolveArgs } from '../injector/MetadataInjector';
-export class ExecutionContext {
-    constructor(instance, methodName, scope) {
+import { resolveArgs } from '../injector/inject';
+export class HookContext {
+    constructor(instance, scope, methodName) {
         this.instance = instance;
-        this.methodName = methodName;
         this.scope = scope;
+        this.methodName = methodName;
     }
     resolveArgs(...args) {
         return resolveArgs(this.instance.constructor, this.methodName)(this.scope, ...args);
@@ -17,3 +17,5 @@ export class ExecutionContext {
         this.instance[this.methodName] = fn(this.scope);
     }
 }
+export const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
+export const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;

package/esm/hooks/hook.js

@@ -1,4 +1,4 @@
-import { ExecutionContext } from './ExecutionContext';
+import { createHookContext } from './HookContext';
 import { promisify } from '../utils';
 export const hook = (key, ...fns) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(key, target.constructor)
@@ -13,14 +13,18 @@ export function getHooks(target, key) {
 export function hasHooks(target, key) {
     return Reflect.hasMetadata(key, target.constructor);
 }
-export const executeHooks = (target, key, { scope, decorateContext = (c) => c, handleError, }) => {
+export const runHooks = (target, key, { scope, createContext = createHookContext, handleError, }) => {
     const hooks = Array.from(getHooks(target, key).entries());
-    const createContext = (methodName) => decorateContext(new ExecutionContext(target, methodName, scope));
     const runExecution = (execute, context) => promisify(execute(context)).catch((e) => handleError(e, scope));
-    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(methodName)))));
+    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(target, scope, methodName)))));
 };
 export const injectProp = (fn) => (context) => context.injectProperty(fn);
 export const invokeExecution = ({ handleResult }) => async (context) => {
     const args = await Promise.all(context.resolveArgs().map(promisify));
     return handleResult(context.invokeMethod({ args }), context);
 };
+/**
+ * @deprecated Use `runHooks` instead
+ * @TODO: Remove in v33
+ */
+export const executeHooks = runHooks;

package/esm/index.js

@@ -3,7 +3,9 @@ export { isDependencyKey, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
-export { MetadataInjector, inject, resolveArgs, getInjectFns } from './injector/MetadataInjector';
+// Injectors
+export { inject, resolveArgs } from './injector/inject';
+export { MetadataInjector } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 // Providers
@@ -20,8 +22,8 @@ export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
 // Hooks
-export { getHooks, hook, hasHooks, executeHooks, injectProp, invokeExecution } from './hooks/hook';
-export { ExecutionContext } from './hooks/ExecutionContext';
+export { getHooks, hook, hasHooks, executeHooks, runHooks, injectProp, invokeExecution } from './hooks/hook';
+export { HookContext } from './hooks/HookContext';
 // Others
 export { by, IMemoKey, byAlias, byAliases } from './by';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/esm/injector/MetadataInjector.js

@@ -1,21 +1,7 @@
-import { constant, fillEmptyIndexes } from '../utils';
-import { setParameterMetadata, getParameterMetadata } from '../metadata';
-const METADATA_KEY = 'inject';
-export const getInjectFns = (Target, methodName) => getParameterMetadata(metaKey(methodName), Target);
-const metaKey = (methodName = 'constructor') => `${METADATA_KEY}:${methodName}`;
-function isInstance(target) {
-    return Object.prototype.hasOwnProperty.call(target, 'constructor');
-}
-export const inject = (fn) => (target, propertyKey, parameterIndex) => {
-    setParameterMetadata(metaKey(propertyKey), fn)(isInstance(target) ? target.constructor : target, propertyKey, parameterIndex);
-};
-export const resolveArgs = (Target, methodName) => {
-    const argsFns = getInjectFns(Target, methodName);
-    return (scope, ...deps) => fillEmptyIndexes(argsFns, deps.map(constant)).map((fn) => fn(scope));
-};
+import { resolveArgs } from './inject';
 export class MetadataInjector {
-    resolve(container, Target, { args: deps }) {
-        const args = resolveArgs(Target)(container, ...deps);
+    resolve(scope, Target, { args: deps }) {
+        const args = resolveArgs(Target)(scope, ...deps);
         return new Target(...args);
     }
 }

package/esm/injector/inject.js

@@ -0,0 +1,11 @@
+import { getParameterMetadata, setParameterMetadata } from '../metadata';
+import { constant, fillEmptyIndexes, isInstance } from '../utils';
+import { hookMetaKey } from '../hooks/HookContext';
+export const inject = (fn) => (target, propertyKey, parameterIndex) => {
+    setParameterMetadata(hookMetaKey(propertyKey), fn)(isInstance(target) ? target.constructor : target, propertyKey, parameterIndex);
+};
+export const resolveArgs = (Target, methodName) => {
+    const argsFns = getInjectFns(Target, methodName);
+    return (scope, ...deps) => fillEmptyIndexes(argsFns, deps.map(constant)).map((fn) => fn(scope));
+};
+const getInjectFns = (Target, methodName) => getParameterMetadata(hookMetaKey(methodName), Target);

package/esm/utils.js

@@ -22,3 +22,6 @@ export function lazyProxy(resolveInstance) {
     });
 }
 export const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));
+export function isInstance(target) {
+    return Object.prototype.hasOwnProperty.call(target, 'constructor');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "32.10.0",
+  "version": "32.11.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "1feb3be27939265fa91d93aabc3c08fd5c235c27"
+  "gitHead": "75d723a20c55049f12bbc0cebe816edf4b4b30a1"
 }

package/typings/by.d.ts

@@ -1,6 +1,6 @@
 import { DependencyKey, IContainer, InjectionToken } from './container/IContainer';
 import { ProviderResolveOptions } from './provider/IProvider';
-import { InjectFn } from './injector/MetadataInjector';
+import { InjectFn } from './hooks/HookContext';
 export type InstancePredicate = (dep: unknown) => boolean;
 export declare const all: InstancePredicate;
 export type IMemo = Map<string, DependencyKey[]>;
@@ -18,7 +18,7 @@ export declare const by: {
         args?: unknown[] | undefined;
         lazy?: boolean | undefined;
     }) => (c: IContainer, ...args: unknown[]) => T;
-    instances: (predicate?: InstancePredicate) => (l: IContainer) => unknown[];
+    instances: (predicate?: InstancePredicate) => (l: IContainer) => object[];
     scope: {
         current: (container: IContainer) => IContainer;
         create: (...tags: string[]) => (l: IContainer) => IContainer;

package/typings/container/AutoMockedContainer.d.ts

@@ -7,7 +7,7 @@ export declare abstract class AutoMockedContainer implements IContainer {
     abstract resolve<T>(key: InjectionToken<T>, options?: ResolveOptions): T;
     dispose(): void;
     register(): this;
-    getInstances(): unknown[];
+    getInstances(): object[];
     removeScope(): void;
     use(): this;
     getRegistrations(): never[];

package/typings/container/Container.d.ts

@@ -20,7 +20,7 @@ export declare class Container implements IContainer {
     resolve<T>(token: InjectionToken<T>, { args, child, lazy }?: ResolveOptions): T;
     createScope(...tags: Tag[]): Container;
     dispose(): void;
-    getInstances(): unknown[];
+    getInstances(): object[];
     hasTag(tag: Tag): boolean;
     use(module: IContainerModule): this;
     hasDependency(key: DependencyKey): boolean;

package/typings/container/EmptyContainer.d.ts

@@ -10,7 +10,7 @@ export declare class EmptyContainer implements IContainer {
     register(key: DependencyKey, value: IProvider): this;
     resolve<T>(key: InjectionToken<T>, options: ResolveOptions): T;
     getRegistrations(): never[];
-    getInstances(): unknown[];
+    getInstances(): object[];
     removeScope(): void;
     use(module: IContainerModule): this;
     add(registration: IRegistration): this;

package/typings/container/IContainer.d.ts

@@ -28,7 +28,7 @@ export interface IContainer extends Resolvable, Tagged {
     register(key: DependencyKey, value: IProvider): this;
     add(registration: IRegistration): this;
     removeScope(child: IContainer): void;
-    getInstances(): unknown[];
+    getInstances(): object[];
     dispose(): void;
     use(module: IContainerModule): this;
     getRegistrations(): IRegistration[];

package/typings/hooks/HookContext.d.ts

@@ -0,0 +1,25 @@
+import { IContainer } from '../container/IContainer';
+export type InjectFn<T = unknown> = (l: IContainer) => T;
+export interface IHookContext {
+    instance: object;
+    scope: IContainer;
+    methodName?: string;
+    resolveArgs(...args: unknown[]): unknown[];
+    invokeMethod({ args }: {
+        args?: unknown[];
+    }): unknown;
+    injectProperty(fn: InjectFn): void;
+}
+export declare class HookContext implements IHookContext {
+    instance: object;
+    scope: IContainer;
+    methodName?: string | undefined;
+    constructor(instance: object, scope: IContainer, methodName?: string | undefined);
+    resolveArgs(...args: unknown[]): unknown[];
+    invokeMethod({ args }: {
+        args?: unknown[];
+    }): unknown;
+    injectProperty(fn: InjectFn): void;
+}
+export declare const createHookContext: (Target: object, scope: IContainer, methodName?: string) => IHookContext;
+export declare const hookMetaKey: (methodName?: string) => string;

package/typings/hooks/hook.d.ts

@@ -1,20 +1,27 @@
 import { IContainer } from '../container/IContainer';
-import { ExecutionContext } from './ExecutionContext';
-import { InjectFn } from '../injector/MetadataInjector';
-export type Execution<T extends ExecutionContext = ExecutionContext> = (context: T) => void | Promise<void>;
-type HookList = Execution[];
-type Hooks = Map<string, HookList>;
-export declare const hook: (key: string | symbol, ...fns: HookList) => (target: object, propertyKey: string | symbol) => void;
-export declare function getHooks(target: object, key: string | symbol): Hooks;
+import { createHookContext, IHookContext, InjectFn } from './HookContext';
+export type Hook<T extends IHookContext = IHookContext> = (context: T) => void | Promise<void>;
+type HooksOfClass = Map<string, Hook[]>;
+export declare const hook: (key: string | symbol, ...fns: Hook[]) => (target: object, propertyKey: string | symbol) => void;
+export declare function getHooks(target: object, key: string | symbol): HooksOfClass;
 export declare function hasHooks(target: object, key: string | symbol): boolean;
-export declare const executeHooks: <Context extends ExecutionContext>(target: object, key: string | symbol, { scope, decorateContext, handleError, }: {
+export declare const runHooks: (target: object, key: string | symbol, { scope, createContext, handleError, }: {
     scope: IContainer;
-    decorateContext?: ((c: ExecutionContext) => Context) | undefined;
+    createContext?: ((Target: object, scope: IContainer, methodName?: string) => IHookContext) | undefined;
     handleError: (e: Error, s: IContainer) => void;
-}) => Promise<any[]>;
-export declare const injectProp: (fn: InjectFn) => Execution;
-type HandleResult = (result: unknown, context: ExecutionContext) => void | Promise<void>;
+}) => Promise<void[]>;
+export declare const injectProp: (fn: InjectFn) => Hook;
+type HandleResult = (result: unknown, context: IHookContext) => void | Promise<void>;
 export declare const invokeExecution: ({ handleResult }: {
     handleResult: HandleResult;
-}) => Execution;
+}) => Hook;
+/**
+ * @deprecated Use `runHooks` instead
+ * @TODO: Remove in v33
+ */
+export declare const executeHooks: (target: object, key: string | symbol, { scope, createContext, handleError, }: {
+    scope: IContainer;
+    createContext?: ((Target: object, scope: IContainer, methodName?: string) => IHookContext) | undefined;
+    handleError: (e: Error, s: IContainer) => void;
+}) => Promise<void[]>;
 export {};

package/typings/index.d.ts

@@ -2,8 +2,9 @@ export { IContainer, Resolvable, IContainerModule, isDependencyKey, DependencyKe
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
-export { IInjector } from './injector/IInjector';
-export { MetadataInjector, inject, resolveArgs, getInjectFns, InjectFn } from './injector/MetadataInjector';
+export { inject, resolveArgs } from './injector/inject';
+export { IInjector, InjectOptions } from './injector/IInjector';
+export { MetadataInjector } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn, ProviderDecorator, ProviderResolveOptions, } from './provider/IProvider';
@@ -17,8 +18,8 @@ export { Registration } from './registration/Registration';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
-export { getHooks, hook, hasHooks, Execution, executeHooks, injectProp, invokeExecution } from './hooks/hook';
-export { ExecutionContext } from './hooks/ExecutionContext';
+export { getHooks, hook, hasHooks, Hook, executeHooks, runHooks, injectProp, invokeExecution } from './hooks/hook';
+export { HookContext, InjectFn } from './hooks/HookContext';
 export { by, InstancePredicate, IMemo, IMemoKey, byAlias, byAliases } from './by';
 export { constructor } from './utils';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/typings/injector/MetadataInjector.d.ts

@@ -1,10 +1,6 @@
 import { IInjector, InjectOptions } from './IInjector';
 import { IContainer } from '../container/IContainer';
 import { constructor } from '../utils';
-export type InjectFn<T = unknown> = (l: IContainer) => T;
-export declare const getInjectFns: (Target: constructor<unknown>, methodName?: string) => InjectFn<unknown>[];
-export declare const inject: (fn: InjectFn) => ParameterDecorator;
-export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, ...deps: unknown[]) => unknown[];
 export declare class MetadataInjector implements IInjector {
-    resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
+    resolve<T>(scope: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
 }

package/typings/injector/inject.d.ts

@@ -0,0 +1,5 @@
+import { constructor } from '../utils';
+import { IContainer } from '../container/IContainer';
+import { InjectFn } from '../hooks/HookContext';
+export declare const inject: (fn: InjectFn) => ParameterDecorator;
+export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, ...deps: unknown[]) => unknown[];

package/typings/utils.d.ts

@@ -5,4 +5,8 @@ export declare function fillEmptyIndexes<T>(baseArr: (T | undefined)[], insertAr
 export declare const constant: <T>(value: T) => () => T;
 export declare const isConstructor: (T: unknown) => T is constructor<unknown>;
 export declare function lazyProxy<T>(resolveInstance: () => T): T;
-export declare const promisify: (arg: unknown) => Promise<any>;
+export declare const promisify: <T>(arg: T | Promise<T>) => Promise<T>;
+export interface InstanceOfClass<T = unknown> {
+    new (...args: unknown[]): T;
+}
+export declare function isInstance(target: object): target is InstanceOfClass<unknown>;

package/cjm/hooks/ExecutionContext.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionContext = void 0;
-const MetadataInjector_1 = require("../injector/MetadataInjector");
-class ExecutionContext {
-    constructor(instance, methodName, scope) {
-        this.instance = instance;
-        this.methodName = methodName;
-        this.scope = scope;
-    }
-    resolveArgs(...args) {
-        return (0, MetadataInjector_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, ...args);
-    }
-    invokeMethod({ args = this.resolveArgs() }) {
-        // @ts-ignore
-        return this.instance[this.methodName](...args);
-    }
-    injectProperty(fn) {
-        // @ts-ignore
-        this.instance[this.methodName] = fn(this.scope);
-    }
-}
-exports.ExecutionContext = ExecutionContext;

package/typings/hooks/ExecutionContext.d.ts

@@ -1,13 +0,0 @@
-import { InjectFn } from '../injector/MetadataInjector';
-import { IContainer } from '../container/IContainer';
-export declare class ExecutionContext {
-    instance: object;
-    methodName: string;
-    scope: IContainer;
-    constructor(instance: object, methodName: string, scope: IContainer);
-    resolveArgs(...args: unknown[]): unknown[];
-    invokeMethod({ args }: {
-        args: unknown[];
-    }): unknown;
-    injectProperty(fn: InjectFn): void;
-}