ts-ioc-container 55.0.0 → 55.1.0

package/cjm/hooks/HooksRunner.js

@@ -10,10 +10,10 @@ class HooksRunner {
     constructor(key) {
         this.key = key;
     }
-    execute(target, { scope, createContext = HookContext_1.createHookContext, predicate = () => true }) {
+    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 = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 const result = execute(context);
                 if (result instanceof Promise) {
@@ -25,10 +25,10 @@ class HooksRunner {
             runMethodHooks(methodName, executions.map(hook_1.toHookFn));
         }
     }
-    async executeAsync(target, { scope, createContext = HookContext_1.createHookContext, predicate = () => true, }) {
+    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 = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 await (0, promise_1.promisify)(execute(context));
             }

package/esm/hooks/HooksRunner.js

@@ -7,10 +7,10 @@ export class HooksRunner {
     constructor(key) {
         this.key = key;
     }
-    execute(target, { scope, createContext = createHookContext, predicate = () => true }) {
+    execute(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
         const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
         const runMethodHooks = (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 const result = execute(context);
                 if (result instanceof Promise) {
@@ -22,10 +22,10 @@ export class HooksRunner {
             runMethodHooks(methodName, executions.map(toHookFn));
         }
     }
-    async executeAsync(target, { scope, createContext = createHookContext, predicate = () => true, }) {
+    async executeAsync(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
         const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
         const runMethodHooks = async (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 await promisify(execute(context));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "55.0.0",
+  "version": "55.1.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "workspaces": [
     "docs"

package/typings/hooks/HooksRunner.d.ts

@@ -1,17 +1,15 @@
-import { createHookContext, type CreateHookContext } from './HookContext';
+import { type CreateHookContext, type IHookContext } from './HookContext';
 import type { IContainer } from '../container/IContainer';
+export type MapHookContext = (context: IHookContext) => IHookContext;
 export type HooksRunnerContext = {
     scope: IContainer;
     createContext?: CreateHookContext;
+    mapContext?: MapHookContext;
     predicate?: (methodName: string) => boolean;
 };
 export declare class HooksRunner {
     private readonly key;
     constructor(key: string | symbol);
-    execute(target: object, { scope, createContext, predicate }: HooksRunnerContext): void;
-    executeAsync(target: object, { scope, createContext, predicate, }: {
-        scope: IContainer;
-        createContext?: typeof createHookContext;
-        predicate?: (methodName: string) => boolean;
-    }): Promise<void[]>;
+    execute(target: object, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): void;
+    executeAsync(target: object, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): Promise<void[]>;
 }

package/typings/index.d.ts

@@ -22,7 +22,7 @@ export { HookContext, createHookContextFactory, createHookContext, type IHookCon
 export { injectProp } from './hooks/injectProp';
 export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule } from './hooks/onConstruct';
 export { onDisposeHooksRunner, onDispose, AddOnDisposeHookModule } from './hooks/onDispose';
-export { HooksRunner, type HooksRunnerContext } from './hooks/HooksRunner';
+export { HooksRunner, type HooksRunnerContext, type MapHookContext } from './hooks/HooksRunner';
 export { InjectionToken } from './token/InjectionToken';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken';
 export { SingleAliasToken, toSingleAlias } from './token/SingleAliasToken';