@illuma/core 1.3.0 → 1.4.0

package/dist/{plugin-container-GF2OqmiJ.d.ts → plugin-container-CXuie89o.d.cts}

@@ -1,4 +1,4 @@
-import { N as NodeToken, M as MultiNodeToken, a as NodeBase } from './types-5mX9F_24.js';
+import { N as NodeToken, M as MultiNodeToken, a as NodeBase } from './types-zryyqrii.cjs';
 
 /**
  * Represents a single dependency injection point in the dependency graph.
@@ -29,6 +29,16 @@ interface iContextScanner {
     scan(factory: any): Set<iInjectionNode<any>>;
 }
 
+/**
+ * Instantiation parameters for creating a new instance of a type `T`.
+ * @template T - The type of the instance to be created.
+ */
+interface iInstantiationParams<T = unknown> {
+    readonly token: NodeBase<T>;
+    readonly factory: () => T;
+}
+type iMiddleware<T = unknown> = (params: iInstantiationParams<T>, next: (params: iInstantiationParams<T>) => T) => T;
+
 declare class ProtoNodeSingle<T = any> {
     readonly token: NodeToken<T>;
     readonly injections: Set<iInjectionNode<any>>;
@@ -67,7 +77,7 @@ declare class TreeNodeSingle<T = any> {
     constructor(proto: ProtoNodeSingle<T>);
     addDependency(node: TreeNode<any>): void;
     collectPool(pool: InjectionPool): void;
-    instantiate(pool?: InjectionPool): void;
+    instantiate(pool?: InjectionPool, middlewares?: iMiddleware[]): void;
     toString(): string;
 }
 declare class TreeNodeTransparent<T = any> {
@@ -81,7 +91,7 @@ declare class TreeNodeTransparent<T = any> {
     constructor(proto: ProtoNodeTransparent<T>);
     addDependency(node: TreeNode<any>): void;
     collectPool(pool: InjectionPool): void;
-    instantiate(pool?: InjectionPool): void;
+    instantiate(pool?: InjectionPool, middlewares?: iMiddleware[]): void;
     toString(): string;
 }
 declare class TreeNodeMulti<T = any> {
@@ -92,7 +102,7 @@ declare class TreeNodeMulti<T = any> {
     allocations: number;
     constructor(proto: ProtoNodeMulti<T>);
     collectPool(pool: InjectionPool): void;
-    instantiate(pool?: InjectionPool): void;
+    instantiate(pool?: InjectionPool, middlewares?: iMiddleware[]): void;
     addDependency(...nodes: TreeNode[]): void;
     toString(): string;
 }
@@ -117,6 +127,7 @@ interface iDiagnosticsModule {
 declare abstract class Illuma {
     private static readonly _diagnostics;
     private static readonly _scanners;
+    protected static readonly _middlewares: iMiddleware[];
     /** @internal */
     static get contextScanners(): ReadonlyArray<iContextScanner>;
     /**
@@ -133,7 +144,17 @@ declare abstract class Illuma {
      * @param scanner - The context scanner instance to add
      */
     static extendContextScanner(scanner: iContextScanner): void;
+    /**
+     * Registers a global middleware to be applied during instance creation.
+     * Typically used for cross-cutting concerns like logging, profiling, or custom instantiation logic.
+     * Function should accept instantiation parameters and a `next` function to proceed with the next middleware or actual instantiation.
+     *
+     * @param m - The middleware function to register
+     */
+    static registerGlobalMiddleware(m: iMiddleware): void;
+    protected readonly middlewares: iMiddleware[];
+    registerMiddleware(m: iMiddleware): void;
     protected static onReport(report: iDiagnosticsReport): void;
 }
 
-export { Illuma as I, type TreeNode as T, type iDiagnosticsModule as a, type iDiagnosticsReport as b, type iContextScanner as c, type iInjectionNode as i };
+export { Illuma as I, type TreeNode as T, type iInjectionNode as a, type iDiagnosticsModule as b, type iDiagnosticsReport as c, type iContextScanner as d, type iInstantiationParams as e, type iMiddleware as i };

package/dist/plugins.cjs

@@ -33,6 +33,7 @@ var Illuma = class _Illuma {
   }
   static _diagnostics = [];
   static _scanners = [];
+  static _middlewares = [];
   /** @internal */
   static get contextScanners() {
     return _Illuma._scanners;
@@ -55,6 +56,20 @@ var Illuma = class _Illuma {
   static extendContextScanner(scanner) {
     _Illuma._scanners.push(scanner);
   }
+  /**
+  * Registers a global middleware to be applied during instance creation.
+  * Typically used for cross-cutting concerns like logging, profiling, or custom instantiation logic.
+  * Function should accept instantiation parameters and a `next` function to proceed with the next middleware or actual instantiation.
+  *
+  * @param m - The middleware function to register
+  */
+  static registerGlobalMiddleware(m) {
+    _Illuma._middlewares.push(m);
+  }
+  middlewares = [];
+  registerMiddleware(m) {
+    this.middlewares.push(m);
+  }
   static onReport(report) {
     for (const diag of _Illuma._diagnostics) diag.onReport(report);
   }

package/dist/plugins.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/plugins.ts","../src/lib/plugins/core/plugin-container.ts","../src/lib/plugins/diagnostics/default-impl.ts"],"sourcesContent":["export * from \"./lib/plugins\";\n","import type { iContextScanner } from \"../context\";\nimport type { iDiagnosticsModule, iDiagnosticsReport } from \"../diagnostics/types\";\n\n/**\n * Global plugin container for managing core plugins such as diagnostics and context scanners.\n */\nexport abstract class Illuma {\n  private static readonly _diagnostics = [] as iDiagnosticsModule[];\n  private static readonly _scanners = [] as iContextScanner[];\n\n  /** @internal */\n  public static get contextScanners(): ReadonlyArray<iContextScanner> {\n    return Illuma._scanners;\n  }\n\n  /**\n   * Extends the diagnostics with a new diagnostics module.\n   * These will be run on diagnostics reports after container bootstrap.\n   *\n   * @param m - The diagnostics module instance to add\n   */\n  public static extendDiagnostics(m: iDiagnosticsModule): void {\n    Illuma._diagnostics.push(m);\n  }\n\n  /**\n   * Extends the context scanners with a new context scanner.\n   * These will be run in injection context scans to detect additional injections (alongside `nodeInject` calls).\n   *\n   * @param scanner - The context scanner instance to add\n   */\n  public static extendContextScanner(scanner: iContextScanner): void {\n    Illuma._scanners.push(scanner);\n  }\n\n  protected static onReport(report: iDiagnosticsReport): void {\n    for (const diag of Illuma._diagnostics) diag.onReport(report);\n  }\n}\n","import type { iDiagnosticsModule, iDiagnosticsReport } from \"./types\";\n\nexport class DiagnosticsDefaultReporter implements iDiagnosticsModule {\n  public onReport(report: iDiagnosticsReport): void {\n    console.log(\"[Illuma] 🧹 Diagnostics:\");\n    console.log(`  Total: ${report.totalNodes} node(s)`);\n    console.log(`  ${report.unusedNodes.length} were not used while bootstrap:`);\n    for (const node of report.unusedNodes) console.log(`    - ${node.toString()}`);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;ACMO,IAAeA,SAAf,MAAeA,QAAAA;EAHtB,OAGsBA;;;EACpB,OAAwBC,eAAe,CAAA;EACvC,OAAwBC,YAAY,CAAA;;EAGpC,WAAkBC,kBAAkD;AAClE,WAAOH,QAAOE;EAChB;;;;;;;EAQA,OAAcE,kBAAkBC,GAA6B;AAC3DL,YAAOC,aAAaK,KAAKD,CAAAA;EAC3B;;;;;;;EAQA,OAAcE,qBAAqBC,SAAgC;AACjER,YAAOE,UAAUI,KAAKE,OAAAA;EACxB;EAEA,OAAiBC,SAASC,QAAkC;AAC1D,eAAWC,QAAQX,QAAOC,aAAcU,MAAKF,SAASC,MAAAA;EACxD;AACF;;;ACpCO,IAAME,6BAAN,MAAMA;EAAb,OAAaA;;;EACJC,SAASC,QAAkC;AAChDC,YAAQC,IAAI,iCAAA;AACZD,YAAQC,IAAI,YAAYF,OAAOG,UAAU,UAAU;AACnDF,YAAQC,IAAI,KAAKF,OAAOI,YAAYC,MAAM,iCAAiC;AAC3E,eAAWC,QAAQN,OAAOI,YAAaH,SAAQC,IAAI,SAASI,KAAKC,SAAQ,CAAA,EAAI;EAC/E;AACF;","names":["Illuma","_diagnostics","_scanners","contextScanners","extendDiagnostics","m","push","extendContextScanner","scanner","onReport","report","diag","DiagnosticsDefaultReporter","onReport","report","console","log","totalNodes","unusedNodes","length","node","toString"]}
+{"version":3,"sources":["../src/plugins.ts","../src/lib/plugins/core/plugin-container.ts","../src/lib/plugins/diagnostics/default-impl.ts"],"sourcesContent":["export * from \"./lib/plugins\";\n","import type { iContextScanner } from \"../context\";\nimport type { iDiagnosticsModule, iDiagnosticsReport } from \"../diagnostics/types\";\nimport type { iMiddleware } from \"../middlewares/types\";\n\n/**\n * Global plugin container for managing core plugins such as diagnostics and context scanners.\n */\nexport abstract class Illuma {\n  private static readonly _diagnostics = [] as iDiagnosticsModule[];\n  private static readonly _scanners = [] as iContextScanner[];\n  protected static readonly _middlewares = [] as iMiddleware[];\n\n  /** @internal */\n  public static get contextScanners(): ReadonlyArray<iContextScanner> {\n    return Illuma._scanners;\n  }\n\n  /**\n   * Extends the diagnostics with a new diagnostics module.\n   * These will be run on diagnostics reports after container bootstrap.\n   *\n   * @param m - The diagnostics module instance to add\n   */\n  public static extendDiagnostics(m: iDiagnosticsModule): void {\n    Illuma._diagnostics.push(m);\n  }\n\n  /**\n   * Extends the context scanners with a new context scanner.\n   * These will be run in injection context scans to detect additional injections (alongside `nodeInject` calls).\n   *\n   * @param scanner - The context scanner instance to add\n   */\n  public static extendContextScanner(scanner: iContextScanner): void {\n    Illuma._scanners.push(scanner);\n  }\n\n  /**\n   * Registers a global middleware to be applied during instance creation.\n   * Typically used for cross-cutting concerns like logging, profiling, or custom instantiation logic.\n   * Function should accept instantiation parameters and a `next` function to proceed with the next middleware or actual instantiation.\n   *\n   * @param m - The middleware function to register\n   */\n  public static registerGlobalMiddleware(m: iMiddleware): void {\n    Illuma._middlewares.push(m);\n  }\n\n  protected readonly middlewares = [] as iMiddleware[];\n  public registerMiddleware(m: iMiddleware): void {\n    this.middlewares.push(m);\n  }\n\n  protected static onReport(report: iDiagnosticsReport): void {\n    for (const diag of Illuma._diagnostics) diag.onReport(report);\n  }\n}\n","import type { iDiagnosticsModule, iDiagnosticsReport } from \"./types\";\n\nexport class DiagnosticsDefaultReporter implements iDiagnosticsModule {\n  public onReport(report: iDiagnosticsReport): void {\n    console.log(\"[Illuma] 🧹 Diagnostics:\");\n    console.log(`  Total: ${report.totalNodes} node(s)`);\n    console.log(`  ${report.unusedNodes.length} were not used while bootstrap:`);\n    for (const node of report.unusedNodes) console.log(`    - ${node.toString()}`);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;ACOO,IAAeA,SAAf,MAAeA,QAAAA;EAHtB,OAGsBA;;;EACpB,OAAwBC,eAAe,CAAA;EACvC,OAAwBC,YAAY,CAAA;EACpC,OAA0BC,eAAe,CAAA;;EAGzC,WAAkBC,kBAAkD;AAClE,WAAOJ,QAAOE;EAChB;;;;;;;EAQA,OAAcG,kBAAkBC,GAA6B;AAC3DN,YAAOC,aAAaM,KAAKD,CAAAA;EAC3B;;;;;;;EAQA,OAAcE,qBAAqBC,SAAgC;AACjET,YAAOE,UAAUK,KAAKE,OAAAA;EACxB;;;;;;;;EASA,OAAcC,yBAAyBJ,GAAsB;AAC3DN,YAAOG,aAAaI,KAAKD,CAAAA;EAC3B;EAEmBK,cAAc,CAAA;EAC1BC,mBAAmBN,GAAsB;AAC9C,SAAKK,YAAYJ,KAAKD,CAAAA;EACxB;EAEA,OAAiBO,SAASC,QAAkC;AAC1D,eAAWC,QAAQf,QAAOC,aAAcc,MAAKF,SAASC,MAAAA;EACxD;AACF;;;ACtDO,IAAME,6BAAN,MAAMA;EAAb,OAAaA;;;EACJC,SAASC,QAAkC;AAChDC,YAAQC,IAAI,iCAAA;AACZD,YAAQC,IAAI,YAAYF,OAAOG,UAAU,UAAU;AACnDF,YAAQC,IAAI,KAAKF,OAAOI,YAAYC,MAAM,iCAAiC;AAC3E,eAAWC,QAAQN,OAAOI,YAAaH,SAAQC,IAAI,SAASI,KAAKC,SAAQ,CAAA,EAAI;EAC/E;AACF;","names":["Illuma","_diagnostics","_scanners","_middlewares","contextScanners","extendDiagnostics","m","push","extendContextScanner","scanner","registerGlobalMiddleware","middlewares","registerMiddleware","onReport","report","diag","DiagnosticsDefaultReporter","onReport","report","console","log","totalNodes","unusedNodes","length","node","toString"]}

package/dist/plugins.d.cts

@@ -1,6 +1,6 @@
-import { a as iDiagnosticsModule, b as iDiagnosticsReport } from './plugin-container-DkECHcvu.cjs';
-export { I as Illuma, c as iContextScanner } from './plugin-container-DkECHcvu.cjs';
-import './types-5mX9F_24.cjs';
+import { b as iDiagnosticsModule, c as iDiagnosticsReport } from './plugin-container-CXuie89o.cjs';
+export { I as Illuma, d as iContextScanner, e as iInstantiationParams, i as iMiddleware } from './plugin-container-CXuie89o.cjs';
+import './types-zryyqrii.cjs';
 
 declare class DiagnosticsDefaultReporter implements iDiagnosticsModule {
     onReport(report: iDiagnosticsReport): void;

package/dist/plugins.d.ts

@@ -1,6 +1,6 @@
-import { a as iDiagnosticsModule, b as iDiagnosticsReport } from './plugin-container-GF2OqmiJ.js';
-export { I as Illuma, c as iContextScanner } from './plugin-container-GF2OqmiJ.js';
-import './types-5mX9F_24.js';
+import { b as iDiagnosticsModule, c as iDiagnosticsReport } from './plugin-container-CG_kjb35.js';
+export { I as Illuma, d as iContextScanner, e as iInstantiationParams, i as iMiddleware } from './plugin-container-CG_kjb35.js';
+import './types-zryyqrii.js';
 
 declare class DiagnosticsDefaultReporter implements iDiagnosticsModule {
     onReport(report: iDiagnosticsReport): void;

package/dist/plugins.js

@@ -8,6 +8,7 @@ var Illuma = class _Illuma {
   }
   static _diagnostics = [];
   static _scanners = [];
+  static _middlewares = [];
   /** @internal */
   static get contextScanners() {
     return _Illuma._scanners;
@@ -30,6 +31,20 @@ var Illuma = class _Illuma {
   static extendContextScanner(scanner) {
     _Illuma._scanners.push(scanner);
   }
+  /**
+  * Registers a global middleware to be applied during instance creation.
+  * Typically used for cross-cutting concerns like logging, profiling, or custom instantiation logic.
+  * Function should accept instantiation parameters and a `next` function to proceed with the next middleware or actual instantiation.
+  *
+  * @param m - The middleware function to register
+  */
+  static registerGlobalMiddleware(m) {
+    _Illuma._middlewares.push(m);
+  }
+  middlewares = [];
+  registerMiddleware(m) {
+    this.middlewares.push(m);
+  }
   static onReport(report) {
     for (const diag of _Illuma._diagnostics) diag.onReport(report);
   }

package/dist/plugins.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/lib/plugins/core/plugin-container.ts","../src/lib/plugins/diagnostics/default-impl.ts"],"sourcesContent":["import type { iContextScanner } from \"../context\";\nimport type { iDiagnosticsModule, iDiagnosticsReport } from \"../diagnostics/types\";\n\n/**\n * Global plugin container for managing core plugins such as diagnostics and context scanners.\n */\nexport abstract class Illuma {\n  private static readonly _diagnostics = [] as iDiagnosticsModule[];\n  private static readonly _scanners = [] as iContextScanner[];\n\n  /** @internal */\n  public static get contextScanners(): ReadonlyArray<iContextScanner> {\n    return Illuma._scanners;\n  }\n\n  /**\n   * Extends the diagnostics with a new diagnostics module.\n   * These will be run on diagnostics reports after container bootstrap.\n   *\n   * @param m - The diagnostics module instance to add\n   */\n  public static extendDiagnostics(m: iDiagnosticsModule): void {\n    Illuma._diagnostics.push(m);\n  }\n\n  /**\n   * Extends the context scanners with a new context scanner.\n   * These will be run in injection context scans to detect additional injections (alongside `nodeInject` calls).\n   *\n   * @param scanner - The context scanner instance to add\n   */\n  public static extendContextScanner(scanner: iContextScanner): void {\n    Illuma._scanners.push(scanner);\n  }\n\n  protected static onReport(report: iDiagnosticsReport): void {\n    for (const diag of Illuma._diagnostics) diag.onReport(report);\n  }\n}\n","import type { iDiagnosticsModule, iDiagnosticsReport } from \"./types\";\n\nexport class DiagnosticsDefaultReporter implements iDiagnosticsModule {\n  public onReport(report: iDiagnosticsReport): void {\n    console.log(\"[Illuma] 🧹 Diagnostics:\");\n    console.log(`  Total: ${report.totalNodes} node(s)`);\n    console.log(`  ${report.unusedNodes.length} were not used while bootstrap:`);\n    for (const node of report.unusedNodes) console.log(`    - ${node.toString()}`);\n  }\n}\n"],"mappings":";;;;AAMO,IAAeA,SAAf,MAAeA,QAAAA;EAHtB,OAGsBA;;;EACpB,OAAwBC,eAAe,CAAA;EACvC,OAAwBC,YAAY,CAAA;;EAGpC,WAAkBC,kBAAkD;AAClE,WAAOH,QAAOE;EAChB;;;;;;;EAQA,OAAcE,kBAAkBC,GAA6B;AAC3DL,YAAOC,aAAaK,KAAKD,CAAAA;EAC3B;;;;;;;EAQA,OAAcE,qBAAqBC,SAAgC;AACjER,YAAOE,UAAUI,KAAKE,OAAAA;EACxB;EAEA,OAAiBC,SAASC,QAAkC;AAC1D,eAAWC,QAAQX,QAAOC,aAAcU,MAAKF,SAASC,MAAAA;EACxD;AACF;;;ACpCO,IAAME,6BAAN,MAAMA;EAAb,OAAaA;;;EACJC,SAASC,QAAkC;AAChDC,YAAQC,IAAI,iCAAA;AACZD,YAAQC,IAAI,YAAYF,OAAOG,UAAU,UAAU;AACnDF,YAAQC,IAAI,KAAKF,OAAOI,YAAYC,MAAM,iCAAiC;AAC3E,eAAWC,QAAQN,OAAOI,YAAaH,SAAQC,IAAI,SAASI,KAAKC,SAAQ,CAAA,EAAI;EAC/E;AACF;","names":["Illuma","_diagnostics","_scanners","contextScanners","extendDiagnostics","m","push","extendContextScanner","scanner","onReport","report","diag","DiagnosticsDefaultReporter","onReport","report","console","log","totalNodes","unusedNodes","length","node","toString"]}
+{"version":3,"sources":["../src/lib/plugins/core/plugin-container.ts","../src/lib/plugins/diagnostics/default-impl.ts"],"sourcesContent":["import type { iContextScanner } from \"../context\";\nimport type { iDiagnosticsModule, iDiagnosticsReport } from \"../diagnostics/types\";\nimport type { iMiddleware } from \"../middlewares/types\";\n\n/**\n * Global plugin container for managing core plugins such as diagnostics and context scanners.\n */\nexport abstract class Illuma {\n  private static readonly _diagnostics = [] as iDiagnosticsModule[];\n  private static readonly _scanners = [] as iContextScanner[];\n  protected static readonly _middlewares = [] as iMiddleware[];\n\n  /** @internal */\n  public static get contextScanners(): ReadonlyArray<iContextScanner> {\n    return Illuma._scanners;\n  }\n\n  /**\n   * Extends the diagnostics with a new diagnostics module.\n   * These will be run on diagnostics reports after container bootstrap.\n   *\n   * @param m - The diagnostics module instance to add\n   */\n  public static extendDiagnostics(m: iDiagnosticsModule): void {\n    Illuma._diagnostics.push(m);\n  }\n\n  /**\n   * Extends the context scanners with a new context scanner.\n   * These will be run in injection context scans to detect additional injections (alongside `nodeInject` calls).\n   *\n   * @param scanner - The context scanner instance to add\n   */\n  public static extendContextScanner(scanner: iContextScanner): void {\n    Illuma._scanners.push(scanner);\n  }\n\n  /**\n   * Registers a global middleware to be applied during instance creation.\n   * Typically used for cross-cutting concerns like logging, profiling, or custom instantiation logic.\n   * Function should accept instantiation parameters and a `next` function to proceed with the next middleware or actual instantiation.\n   *\n   * @param m - The middleware function to register\n   */\n  public static registerGlobalMiddleware(m: iMiddleware): void {\n    Illuma._middlewares.push(m);\n  }\n\n  protected readonly middlewares = [] as iMiddleware[];\n  public registerMiddleware(m: iMiddleware): void {\n    this.middlewares.push(m);\n  }\n\n  protected static onReport(report: iDiagnosticsReport): void {\n    for (const diag of Illuma._diagnostics) diag.onReport(report);\n  }\n}\n","import type { iDiagnosticsModule, iDiagnosticsReport } from \"./types\";\n\nexport class DiagnosticsDefaultReporter implements iDiagnosticsModule {\n  public onReport(report: iDiagnosticsReport): void {\n    console.log(\"[Illuma] 🧹 Diagnostics:\");\n    console.log(`  Total: ${report.totalNodes} node(s)`);\n    console.log(`  ${report.unusedNodes.length} were not used while bootstrap:`);\n    for (const node of report.unusedNodes) console.log(`    - ${node.toString()}`);\n  }\n}\n"],"mappings":";;;;AAOO,IAAeA,SAAf,MAAeA,QAAAA;EAHtB,OAGsBA;;;EACpB,OAAwBC,eAAe,CAAA;EACvC,OAAwBC,YAAY,CAAA;EACpC,OAA0BC,eAAe,CAAA;;EAGzC,WAAkBC,kBAAkD;AAClE,WAAOJ,QAAOE;EAChB;;;;;;;EAQA,OAAcG,kBAAkBC,GAA6B;AAC3DN,YAAOC,aAAaM,KAAKD,CAAAA;EAC3B;;;;;;;EAQA,OAAcE,qBAAqBC,SAAgC;AACjET,YAAOE,UAAUK,KAAKE,OAAAA;EACxB;;;;;;;;EASA,OAAcC,yBAAyBJ,GAAsB;AAC3DN,YAAOG,aAAaI,KAAKD,CAAAA;EAC3B;EAEmBK,cAAc,CAAA;EAC1BC,mBAAmBN,GAAsB;AAC9C,SAAKK,YAAYJ,KAAKD,CAAAA;EACxB;EAEA,OAAiBO,SAASC,QAAkC;AAC1D,eAAWC,QAAQf,QAAOC,aAAcc,MAAKF,SAASC,MAAAA;EACxD;AACF;;;ACtDO,IAAME,6BAAN,MAAMA;EAAb,OAAaA;;;EACJC,SAASC,QAAkC;AAChDC,YAAQC,IAAI,iCAAA;AACZD,YAAQC,IAAI,YAAYF,OAAOG,UAAU,UAAU;AACnDF,YAAQC,IAAI,KAAKF,OAAOI,YAAYC,MAAM,iCAAiC;AAC3E,eAAWC,QAAQN,OAAOI,YAAaH,SAAQC,IAAI,SAASI,KAAKC,SAAQ,CAAA,EAAI;EAC/E;AACF;","names":["Illuma","_diagnostics","_scanners","_middlewares","contextScanners","extendDiagnostics","m","push","extendContextScanner","scanner","registerGlobalMiddleware","middlewares","registerMiddleware","onReport","report","diag","DiagnosticsDefaultReporter","onReport","report","console","log","totalNodes","unusedNodes","length","node","toString"]}

package/dist/testkit.cjs

@@ -226,6 +226,7 @@ var Illuma = class _Illuma {
   }
   static _diagnostics = [];
   static _scanners = [];
+  static _middlewares = [];
   /** @internal */
   static get contextScanners() {
     return _Illuma._scanners;
@@ -248,6 +249,20 @@ var Illuma = class _Illuma {
   static extendContextScanner(scanner) {
     _Illuma._scanners.push(scanner);
   }
+  /**
+  * Registers a global middleware to be applied during instance creation.
+  * Typically used for cross-cutting concerns like logging, profiling, or custom instantiation logic.
+  * Function should accept instantiation parameters and a `next` function to proceed with the next middleware or actual instantiation.
+  *
+  * @param m - The middleware function to register
+  */
+  static registerGlobalMiddleware(m) {
+    _Illuma._middlewares.push(m);
+  }
+  middlewares = [];
+  registerMiddleware(m) {
+    this.middlewares.push(m);
+  }
   static onReport(report) {
     for (const diag of _Illuma._diagnostics) diag.onReport(report);
   }
@@ -452,7 +467,34 @@ function isNotTransparentProto(proto) {
 }
 __name(isNotTransparentProto, "isNotTransparentProto");
 
+// src/lib/utils/injector.ts
+var InjectorImpl = class {
+  static {
+    __name(this, "InjectorImpl");
+  }
+  container;
+  constructor(container) {
+    this.container = container;
+  }
+  get(token) {
+    return this.container.get(token);
+  }
+  produce(fn) {
+    return this.container.produce(fn);
+  }
+};
+var Injector = new NodeToken("Injector");
+
 // src/lib/provider/tree-node.ts
+function runMiddlewares(middlewares, params) {
+  const ms = middlewares;
+  const next = /* @__PURE__ */ __name((i, current) => {
+    if (i >= ms.length) return current.factory();
+    return ms[i](current, (nextParams) => next(i + 1, nextParams));
+  }, "next");
+  return next(0, params);
+}
+__name(runMiddlewares, "runMiddlewares");
 function retrieverFactory(node, deps, transparentDeps) {
   return (token, optional) => {
     const depNode = deps.get(token);
@@ -470,10 +512,12 @@ var TreeRootNode = class {
     __name(this, "TreeRootNode");
   }
   instant;
+  middlewares;
   _deps = /* @__PURE__ */ new Set();
   _treePool = /* @__PURE__ */ new WeakMap();
-  constructor(instant = true) {
+  constructor(instant = true, middlewares = []) {
     this.instant = instant;
+    this.middlewares = middlewares;
   }
   get dependencies() {
     return this._deps;
@@ -484,14 +528,14 @@ var TreeRootNode = class {
   build() {
     for (const dep of this._deps) {
       if ("token" in dep.proto) this._treePool.set(dep.proto.token, dep);
-      if (this.instant) dep.instantiate(this._treePool);
+      if (this.instant) dep.instantiate(this._treePool, this.middlewares);
       else dep.collectPool(this._treePool);
     }
   }
   find(token) {
     const node = this._treePool.get(token);
     if (!node) return null;
-    if (!this.instant) node.instantiate(this._treePool);
+    if (!this.instant) node.instantiate(this._treePool, this.middlewares);
     return node;
   }
   toString() {
@@ -516,6 +560,10 @@ var TreeNodeSingle = class {
   }
   constructor(proto) {
     this.proto = proto;
+    if (proto.token === Injector) {
+      this._instance = proto.factory();
+      this._resolved = true;
+    }
   }
   addDependency(node) {
     if (node instanceof TreeNodeTransparent) this._transparent.add(node);
@@ -527,14 +575,18 @@ var TreeNodeSingle = class {
     for (const dep of this._transparent) dep.collectPool(pool);
     pool.set(this.proto.token, this);
   }
-  instantiate(pool) {
+  instantiate(pool, middlewares = []) {
     if (this._resolved) return;
-    for (const node of this._deps.values()) node.instantiate(pool);
-    for (const dep of this._transparent) dep.instantiate(pool);
+    for (const node of this._deps.values()) node.instantiate(pool, middlewares);
+    for (const dep of this._transparent) dep.instantiate(pool, middlewares);
     const retriever = retrieverFactory(this.proto.token, this._deps, this._transparent);
     const factory = this.proto.factory ?? this.proto.token.opts?.factory;
     if (!factory) throw InjectionError.notFound(this.proto.token);
-    this._instance = InjectionContext.instantiate(factory, retriever);
+    const contextFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(factory, retriever), "contextFactory");
+    this._instance = runMiddlewares(middlewares, {
+      token: this.proto.token,
+      factory: contextFactory
+    });
     this._resolved = true;
     if (pool) pool.set(this.proto.token, this);
   }
@@ -568,12 +620,16 @@ var TreeNodeTransparent = class _TreeNodeTransparent {
     for (const node of this._deps.values()) node.collectPool(pool);
     for (const dep of this._transparent) dep.collectPool(pool);
   }
-  instantiate(pool) {
+  instantiate(pool, middlewares = []) {
     if (this._resolved) return;
-    for (const dep of this._transparent) dep.instantiate(pool);
-    for (const node of this._deps.values()) node.instantiate(pool);
+    for (const dep of this._transparent) dep.instantiate(pool, middlewares);
+    for (const node of this._deps.values()) node.instantiate(pool, middlewares);
     const retriever = retrieverFactory(this.proto.parent.token, this._deps, this._transparent);
-    this._instance = InjectionContext.instantiate(this.proto.factory, retriever);
+    const refFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(this.proto.factory, retriever), "refFactory");
+    this._instance = runMiddlewares(middlewares, {
+      token: this.proto.parent.token,
+      factory: refFactory
+    });
     this._resolved = true;
   }
   toString() {
@@ -596,10 +652,10 @@ var TreeNodeMulti = class _TreeNodeMulti {
     for (const dep of this._deps) dep.collectPool(pool);
     pool.set(this.proto.token, this);
   }
-  instantiate(pool) {
+  instantiate(pool, middlewares = []) {
     if (this._resolved) return;
     for (const dep of this._deps) {
-      dep.instantiate(pool);
+      dep.instantiate(pool, middlewares);
       if (dep instanceof TreeNodeSingle) {
         this.instance.push(dep.instance);
       } else if (dep instanceof _TreeNodeMulti) {
@@ -754,24 +810,6 @@ function resolveTreeNode(rootProto, cache, singleNodes, multiNodes, upstreamGett
 }
 __name(resolveTreeNode, "resolveTreeNode");
 
-// src/lib/utils/injector.ts
-var InjectorImpl = class {
-  static {
-    __name(this, "InjectorImpl");
-  }
-  container;
-  constructor(container) {
-    this.container = container;
-  }
-  get(token) {
-    return this.container.get(token);
-  }
-  produce(fn) {
-    return this.container.produce(fn);
-  }
-};
-var Injector = new NodeToken("Injector");
-
 // src/lib/container/container.ts
 var NodeContainer = class extends Illuma {
   static {
@@ -901,7 +939,11 @@ var NodeContainer = class extends Illuma {
     return parentNode.findNode(token);
   }
   _buildInjectionTree() {
-    const root = new TreeRootNode(this._opts?.instant);
+    const middlewares = [
+      ...Illuma._middlewares,
+      ...this.collectMiddlewares()
+    ];
+    const root = new TreeRootNode(this._opts?.instant, middlewares);
     const cache = /* @__PURE__ */ new Map();
     const nodes = [
       ...this._protoNodes.values(),
@@ -918,6 +960,12 @@ var NodeContainer = class extends Illuma {
     this._multiProtoNodes.clear();
     return root;
   }
+  collectMiddlewares() {
+    return [
+      ...this._parent && "collectMiddlewares" in this._parent && typeof this._parent.collectMiddlewares === "function" ? this._parent.collectMiddlewares() : [],
+      ...this.middlewares
+    ];
+  }
   /**
   * Bootstraps the container by resolving the dependency trees and instantiating all providers.
   * This must be called after all providers are registered and before calling {@link get}.