ts-ioc-container 33.1.0 → 33.3.0

package/cjm/hooks/hook.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.injectProp = exports.runHooksAsync = exports.runHooks = exports.hasHooks = exports.getHooks = exports.hook = void 0;
 const HookContext_1 = require("./HookContext");
 const utils_1 = require("../utils");
+const isHookClassConstructor = (execute) => {
+    return (0, utils_1.isConstructor)(execute) && execute.prototype.execute;
+};
 const hook = (key, ...fns) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(key, target.constructor)
         ? Reflect.getMetadata(key, target.constructor)
@@ -19,19 +22,30 @@ function hasHooks(target, key) {
     return Reflect.hasMetadata(key, target.constructor);
 }
 exports.hasHooks = hasHooks;
-const runHooks = (target, key, { scope, createContext = HookContext_1.createHookContext, }) => {
-    const hooks = Array.from(getHooks(target, key).entries());
+const runHooks = (target, key, { scope, createContext = HookContext_1.createHookContext, predicate = () => true, }) => {
+    const hooks = Array.from(getHooks(target, key).entries()).filter(([methodName]) => predicate(methodName));
     for (const [methodName, executions] of hooks) {
         for (const execute of executions) {
-            execute(createContext(target, scope, methodName));
+            const context = createContext(target, scope, methodName);
+            if (isHookClassConstructor(execute)) {
+                scope.resolve(execute).execute(context);
+            }
+            else {
+                execute(context);
+            }
         }
     }
 };
 exports.runHooks = runHooks;
-const runHooksAsync = (target, key, { scope, createContext = HookContext_1.createHookContext, }) => {
-    const hooks = Array.from(getHooks(target, key).entries());
-    const runExecution = (execute, context) => (0, utils_1.promisify)(execute(context));
-    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(target, scope, methodName)))));
+const runHooksAsync = (target, key, { scope, createContext = HookContext_1.createHookContext, predicate = () => true, }) => {
+    const hooks = Array.from(getHooks(target, key).entries()).filter(([methodName]) => predicate(methodName));
+    const runExecution = (execute, context) => isHookClassConstructor(execute)
+        ? (0, utils_1.promisify)(context.scope.resolve(execute).execute(context))
+        : (0, utils_1.promisify)(execute(context));
+    return Promise.all(hooks.flatMap(([methodName, executions]) => {
+        const context = createContext(target, scope, methodName);
+        return executions.map((execute) => runExecution(execute, context));
+    }));
 };
 exports.runHooksAsync = runHooksAsync;
 const injectProp = (fn) => (context) => context.setProperty(fn);

package/esm/hooks/hook.js

@@ -1,5 +1,8 @@
 import { createHookContext } from './HookContext';
-import { promisify } from '../utils';
+import { isConstructor, promisify } from '../utils';
+const isHookClassConstructor = (execute) => {
+    return isConstructor(execute) && execute.prototype.execute;
+};
 export const hook = (key, ...fns) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(key, target.constructor)
         ? Reflect.getMetadata(key, target.constructor)
@@ -13,17 +16,28 @@ export function getHooks(target, key) {
 export function hasHooks(target, key) {
     return Reflect.hasMetadata(key, target.constructor);
 }
-export const runHooks = (target, key, { scope, createContext = createHookContext, }) => {
-    const hooks = Array.from(getHooks(target, key).entries());
+export const runHooks = (target, key, { scope, createContext = createHookContext, predicate = () => true, }) => {
+    const hooks = Array.from(getHooks(target, key).entries()).filter(([methodName]) => predicate(methodName));
     for (const [methodName, executions] of hooks) {
         for (const execute of executions) {
-            execute(createContext(target, scope, methodName));
+            const context = createContext(target, scope, methodName);
+            if (isHookClassConstructor(execute)) {
+                scope.resolve(execute).execute(context);
+            }
+            else {
+                execute(context);
+            }
         }
     }
 };
-export const runHooksAsync = (target, key, { scope, createContext = createHookContext, }) => {
-    const hooks = Array.from(getHooks(target, key).entries());
-    const runExecution = (execute, context) => promisify(execute(context));
-    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(target, scope, methodName)))));
+export const runHooksAsync = (target, key, { scope, createContext = createHookContext, predicate = () => true, }) => {
+    const hooks = Array.from(getHooks(target, key).entries()).filter(([methodName]) => predicate(methodName));
+    const runExecution = (execute, context) => isHookClassConstructor(execute)
+        ? promisify(context.scope.resolve(execute).execute(context))
+        : promisify(execute(context));
+    return Promise.all(hooks.flatMap(([methodName, executions]) => {
+        const context = createContext(target, scope, methodName);
+        return executions.map((execute) => runExecution(execute, context));
+    }));
 };
 export const injectProp = (fn) => (context) => context.setProperty(fn);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "33.1.0",
+  "version": "33.3.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "284fe762ac07beb7f3747dfb5faf3409055d75df"
+  "gitHead": "5313997379db49d84f62a6acee5b7ae42c51b32f"
 }

package/typings/hooks/HookContext.d.ts

@@ -23,5 +23,6 @@ export declare class HookContext implements IHookContext {
     setProperty(fn: InjectFn): void;
     getProperty(): unknown;
 }
-export declare const createHookContext: (Target: object, scope: IContainer, methodName?: string) => IHookContext;
+export type CreateHookContext = (Target: object, scope: IContainer, methodName?: string) => IHookContext;
+export declare const createHookContext: CreateHookContext;
 export declare const hookMetaKey: (methodName?: string) => string;

package/typings/hooks/hook.d.ts

@@ -1,17 +1,23 @@
 import { IContainer } from '../container/IContainer';
-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;
+import { CreateHookContext, createHookContext, IHookContext, InjectFn } from './HookContext';
+import { constructor } from '../utils';
+export type HookFn<T extends IHookContext = IHookContext> = (context: T) => void | Promise<void>;
+export interface HookClass<T extends IHookContext = IHookContext> {
+    execute(context: Omit<T, 'scope'>): void | Promise<void>;
+}
+type HooksOfClass = Map<string, (HookFn | constructor<HookClass>)[]>;
+export declare const hook: (key: string | symbol, ...fns: (HookFn | constructor<HookClass>)[]) => (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 runHooks: (target: object, key: string | symbol, { scope, createContext, }: {
+export declare const runHooks: (target: object, key: string | symbol, { scope, createContext, predicate, }: {
     scope: IContainer;
-    createContext?: ((Target: object, scope: IContainer, methodName?: string) => IHookContext) | undefined;
+    createContext?: CreateHookContext | undefined;
+    predicate?: ((methodName: string) => boolean) | undefined;
 }) => void;
-export declare const runHooksAsync: (target: object, key: string | symbol, { scope, createContext, }: {
+export declare const runHooksAsync: (target: object, key: string | symbol, { scope, createContext, predicate, }: {
     scope: IContainer;
-    createContext?: ((Target: object, scope: IContainer, methodName?: string) => IHookContext) | undefined;
+    createContext?: CreateHookContext | undefined;
+    predicate?: ((methodName: string) => boolean) | undefined;
 }) => Promise<void[]>;
-export declare const injectProp: (fn: InjectFn) => Hook;
+export declare const injectProp: (fn: InjectFn) => HookFn;
 export {};

package/typings/index.d.ts

@@ -18,7 +18,7 @@ export { Registration } from './registration/Registration';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
-export { getHooks, hook, hasHooks, Hook, runHooks, runHooksAsync, injectProp } from './hooks/hook';
+export { getHooks, hook, hasHooks, HookFn, HookClass, runHooks, runHooksAsync, injectProp } from './hooks/hook';
 export { HookContext, InjectFn, IHookContext } from './hooks/HookContext';
 export { by, InstancePredicate, IMemo, IMemoKey, byAlias, byAliases, depKey } from './by';
 export { constructor } from './utils';