@illuma/core 1.5.0 → 1.5.2

package/dist/index.js

@@ -347,7 +347,7 @@ __name(isNotFoundError, "isNotFoundError");
 
 // src/lib/api/decorator.ts
 var tokenRegistry = /* @__PURE__ */ new WeakMap();
-var INJECTION_SYMBOL = Symbol("Injectable");
+var INJECTION_SYMBOL = /* @__PURE__ */ Symbol("Injectable");
 function NodeInjectable() {
   return (ctor) => {
     const nodeToken = new NodeToken(`_${ctor.name}`, {
@@ -491,6 +491,17 @@ __name(nodeInject, "nodeInject");
 // src/lib/container/container.ts
 init_plugin_container();
 
+// src/lib/plugins/middlewares/runner.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");
+
 // src/lib/provider/extractor.ts
 function extractProvider(provider) {
   if ("value" in provider) return () => provider.value;
@@ -596,24 +607,15 @@ var InjectorImpl = class {
 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);
     if (!depNode && !optional) {
-      const transparent = Array.from(transparentDeps).find((n) => "proto" in n && n.proto.parent.token === token);
+      const transparent = transparentDeps.get(token);
       if (transparent) return transparent.instance;
       throw InjectionError.untracked(token, node);
     }
-    return depNode?.instance ?? null;
+    return depNode ? depNode.instance : null;
   };
 }
 __name(retrieverFactory, "retrieverFactory");
@@ -624,7 +626,7 @@ var TreeRootNode = class {
   instant;
   middlewares;
   _deps = /* @__PURE__ */ new Set();
-  _treePool = /* @__PURE__ */ new WeakMap();
+  _treePool = /* @__PURE__ */ new Map();
   constructor(instant = true, middlewares = []) {
     this.instant = instant;
     this.middlewares = middlewares;
@@ -689,7 +691,11 @@ var TreeNodeSingle = class {
     if (this._resolved) return;
     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 transparentMap = /* @__PURE__ */ new Map();
+    for (const tNode of this._transparent) {
+      transparentMap.set(tNode.proto.parent.token, tNode);
+    }
+    const retriever = retrieverFactory(this.proto.token, this._deps, transparentMap);
     const factory = this.proto.factory ?? this.proto.token.opts?.factory;
     if (!factory) throw InjectionError.notFound(this.proto.token);
     const contextFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(factory, retriever), "contextFactory");
@@ -738,7 +744,11 @@ var TreeNodeTransparent = class _TreeNodeTransparent {
     if (this._resolved) return;
     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);
+    const transparentMap = /* @__PURE__ */ new Map();
+    for (const tNode of this._transparent) {
+      transparentMap.set(tNode.proto.parent.token, tNode);
+    }
+    const retriever = retrieverFactory(this.proto.parent.token, this._deps, transparentMap);
     const refFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(this.proto.factory, retriever), "refFactory");
     this._instance = runMiddlewares(middlewares, {
       token: this.proto.parent.token,
@@ -1271,12 +1281,33 @@ var NodeContainer = class extends Illuma {
     if (isConstructor(fn) && !isInjectable(fn)) {
       throw InjectionError.invalidCtor(fn);
     }
-    const factory = isInjectable(fn) ? () => new fn() : fn;
-    return InjectionContext.instantiate(factory, (t, optional) => {
-      if (!this._rootNode) throw InjectionError.notBootstrapped();
-      const node = this._rootNode.find(t);
-      if (!node && !optional) throw InjectionError.notFound(t);
+    let factory;
+    if (isInjectable(fn)) {
+      const f = getInjectableToken(fn).opts?.factory;
+      if (!f) factory = /* @__PURE__ */ __name(() => new fn(), "factory");
+      else factory = /* @__PURE__ */ __name(() => getInjectableToken(fn).opts?.factory?.(), "factory");
+    } else {
+      factory = fn;
+    }
+    const rootNode = this._rootNode;
+    if (!rootNode) throw InjectionError.notBootstrapped();
+    const retriever = /* @__PURE__ */ __name((token, optional) => {
+      const node = rootNode.find(token);
+      if (!node && !optional) throw InjectionError.notFound(token);
       return node ? node.instance : null;
+    }, "retriever");
+    const deps = InjectionContext.scan(factory);
+    const middlewares = [
+      ...Illuma._middlewares,
+      ...this.collectMiddlewares()
+    ];
+    const contextFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(factory, retriever), "contextFactory");
+    return runMiddlewares(middlewares, {
+      token: new NodeToken("ProducedNode"),
+      deps: new Set([
+        ...deps.values()
+      ].map((d) => d.token)),
+      factory: contextFactory
     });
   }
 };