@illuma/core 1.2.1 → 1.3.0

package/dist/index.d.ts

@@ -1,12 +1,13 @@
-import { C as Ctor, N as NodeToken, a as NodeBase, P as Provider, T as Token, M as MultiNodeToken } from './token-BvQrvm-Q.js';
-export { e as extractToken, g as iNodeAliasProvider, f as iNodeClassProvider, d as iNodeFactoryProvider, h as iNodeProvider, b as iNodeTokenBaseOptions, c as iNodeValueProvider, i as isNodeBase } from './token-BvQrvm-Q.js';
-import { i as iNodeInjectorOptions, E as ExtractInjectedType } from './injection-D22uAh1O.js';
-export { N as NodeInjectFn, n as nodeInject } from './injection-D22uAh1O.js';
-import { i as iInjectionNode, T as TreeNode, I as Illuma } from './plugin-container-CUw26ZhP.js';
+import { C as Ctor, N as NodeToken, P as Provider, T as Token, M as MultiNodeToken, a as NodeBase } from './types-5mX9F_24.js';
+export { e as extractToken, i as isNodeBase } from './types-5mX9F_24.js';
+import { I as InjectorFn, i as iNodeInjectorOptions, E as ExtractInjectedType } from './injection-C2z7Ycba.js';
+export { N as NodeInjectFn, n as nodeInject } from './injection-C2z7Ycba.js';
+import { T as TreeNode, I as Illuma, i as iInjectionNode } from './plugin-container-GF2OqmiJ.js';
 
 /**
  * Symbol used to mark classes as injectable and store their associated token.
  * @internal
+ * @deprecated Use internal registry instead
  */
 declare const INJECTION_SYMBOL: unique symbol;
 /**
@@ -40,6 +41,7 @@ declare function NodeInjectable<T>(): (ctor: Ctor<T>) => Ctor<T>;
  * @example
  * ```typescript
  * import { makeInjectable } from '@illuma/core';
+import { InjectionError } from '../errors';
  *
  * class _UserService {
  *   public getUser() {
@@ -53,55 +55,21 @@ declare function NodeInjectable<T>(): (ctor: Ctor<T>) => Ctor<T>;
  */
 declare function makeInjectable<T>(ctor: Ctor<T>): Ctor<T>;
 /** @internal */
-declare function isInjectable<T>(ctor: unknown): ctor is Ctor<T> & {
-    [INJECTION_SYMBOL]: NodeToken<T>;
-};
+declare function isInjectable<T>(ctor: unknown): ctor is Ctor<T>;
 /** @internal */
-declare function getInjectableToken<T>(ctor: Ctor<T> & {
-    [INJECTION_SYMBOL]: NodeToken<T>;
-}): NodeToken<T>;
+declare function getInjectableToken<T>(ctor: Ctor<T>): NodeToken<T>;
 declare function isConstructor(fn: unknown): fn is Ctor<any>;
-
-/** @internal */
-type InjectorFn = (token: NodeBase<any>, optional?: boolean) => any;
 /**
- * Internal context manager for tracking dependency injections during factory execution.
- * This class manages the injection context lifecycle and tracks all injection calls.
+ * Registers a class as injectable with a specific token.
+ * Use this function to manually associate a class with a token.
  *
- * @internal
+ * Normally, the {@link NodeInjectable} and {@link makeInjectable} decorator is used to mark classes as injectable,
+ * but if developing a plugin that requires manual registration, this function can be used.
+ *
+ * @param ctor - The class constructor to register
+ * @param token - The token to associate with the class
  */
-declare abstract class InjectionContext {
-    static contextOpen: boolean;
-    static readonly _calls: Set<iInjectionNode<any>>;
-    static injector: InjectorFn | null;
-    private static readonly _scanners;
-    /**
-     * Adds a dependency to the current injection context.
-     * Called by `nodeInject` when a dependency is requested.
-     *
-     * @param node - The injection node representing the dependency
-     * @throws {InjectionError} If called outside of an active injection context
-     */
-    static addDep(node: iInjectionNode<any>): void;
-    /**
-     * Opens a new injection context.
-     * Resets the calls set and sets the injector if provided.
-     *
-     * @param injector - Optional injector function to use for resolving dependencies
-     */
-    /**
-     * Scans a factory function for dependencies.
-     * Executes the factory in a dry-run mode to capture `nodeInject` calls.
-     * Also runs registered context scanners.
-     *
-     * @param factory - The factory function to scan
-     * @returns A set of detected injection nodes
-     */
-    static open(injector?: InjectorFn): void;
-    static scan(factory: any): Set<iInjectionNode<any>>;
-    static instantiate<T>(factory: () => T, injector: InjectorFn): T;
-    static closeAndReport(): Set<iInjectionNode<any>>;
-}
+declare function registerClassAsInjectable<T>(ctor: Ctor<T>, token: NodeToken<T>): void;
 
 /**
  * Configuration options for the NodeContainer.
@@ -257,6 +225,45 @@ declare class NodeContainer extends Illuma implements iDIContainer {
     produce<T>(fn: Ctor<T> | (() => T)): T;
 }
 
+/**
+ * Internal context manager for tracking dependency injections during factory execution.
+ * This class manages the injection context lifecycle and tracks all injection calls.
+ *
+ * @internal
+ */
+declare abstract class InjectionContext {
+    static contextOpen: boolean;
+    static readonly _calls: Set<iInjectionNode<any>>;
+    static injector: InjectorFn | null;
+    private static readonly _scanners;
+    /**
+     * Adds a dependency to the current injection context.
+     * Called by `nodeInject` when a dependency is requested.
+     *
+     * @param node - The injection node representing the dependency
+     * @throws {InjectionError} If called outside of an active injection context
+     */
+    static addDep(node: iInjectionNode<any>): void;
+    /**
+     * Opens a new injection context.
+     * Resets the calls set and sets the injector if provided.
+     *
+     * @param injector - Optional injector function to use for resolving dependencies
+     */
+    /**
+     * Scans a factory function for dependencies.
+     * Executes the factory in a dry-run mode to capture `nodeInject` calls.
+     * Also runs registered context scanners.
+     *
+     * @param factory - The factory function to scan
+     * @returns A set of detected injection nodes
+     */
+    static open(injector?: InjectorFn): void;
+    static scan(factory: any): Set<iInjectionNode<any>>;
+    static instantiate<T>(factory: () => T, injector: InjectorFn): T;
+    static closeAndReport(): Set<iInjectionNode<any>>;
+}
+
 declare const ERR_CODES: {
     readonly DUPLICATE_PROVIDER: 100;
     readonly DUPLICATE_FACTORY: 101;
@@ -419,4 +426,4 @@ declare function injectEntryAsync<T>(fn: MaybeAsyncFactory<iEntrypointConfig<Nod
 declare function injectEntryAsync<T>(fn: MaybeAsyncFactory<iEntrypointConfig<Ctor<T>>>, opts?: iInjectionOptions): () => Promise<T>;
 declare function injectEntryAsync<T>(fn: MaybeAsyncFactory<iEntrypointConfig<MultiNodeToken<T>>>, opts?: iInjectionOptions): () => Promise<T>;
 
-export { Ctor, ExtractInjectedType, ERR_CODES as ILLUMA_ERR_CODES, INJECTION_SYMBOL, InjectionContext, InjectionError, Injector, type InjectorFn, InjectorImpl, MultiNodeToken, NodeBase, NodeContainer, NodeInjectable, NodeToken, Provider, Token, getInjectableToken, type iEntrypointConfig, iInjectionNode, type iInjector, iNodeInjectorOptions, injectAsync, injectDefer, injectEntryAsync, injectGroupAsync, isConstructor, isInjectable, makeInjectable };
+export { ExtractInjectedType, ERR_CODES as ILLUMA_ERR_CODES, INJECTION_SYMBOL, InjectionContext, InjectionError, Injector, InjectorFn, InjectorImpl, MultiNodeToken, NodeBase, NodeContainer, NodeInjectable, NodeToken, getInjectableToken, type iContainerOptions, type iDIContainer, type iEntrypointConfig, iInjectionNode, type iInjector, iNodeInjectorOptions, injectAsync, injectDefer, injectEntryAsync, injectGroupAsync, isConstructor, isInjectable, makeInjectable, registerClassAsInjectable };

package/dist/index.js

@@ -1,6 +1,84 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
+// src/lib/api/token.ts
+var NodeBase = class {
+  static {
+    __name(this, "NodeBase");
+  }
+  name;
+  opts;
+  constructor(name, opts) {
+    this.name = name;
+    this.opts = opts;
+  }
+  /** Provides this token with a value */
+  withValue(value) {
+    return {
+      provide: this,
+      value
+    };
+  }
+  /** Provides this token using a factory function */
+  withFactory(factory) {
+    return {
+      provide: this,
+      factory
+    };
+  }
+  /** Provides this token using a class constructor */
+  withClass(ctor) {
+    return {
+      provide: this,
+      useClass: ctor
+    };
+  }
+  /** Creates an alias to another token */
+  withAlias(alias) {
+    return {
+      provide: this,
+      alias
+    };
+  }
+  toString() {
+    return `Token[${this.name}]`;
+  }
+};
+var NodeToken = class extends NodeBase {
+  static {
+    __name(this, "NodeToken");
+  }
+  multi = false;
+  toString() {
+    return `NodeToken[${this.name}]`;
+  }
+};
+var MultiNodeToken = class extends NodeBase {
+  static {
+    __name(this, "MultiNodeToken");
+  }
+  multi = true;
+  toString() {
+    return `MultiNodeToken[${this.name}]`;
+  }
+};
+function isNodeBase(specimen) {
+  return specimen instanceof NodeToken || specimen instanceof MultiNodeToken;
+}
+__name(isNodeBase, "isNodeBase");
+function extractToken(provider, isAlias = false) {
+  let token = null;
+  if (isInjectable(provider)) {
+    token = getInjectableToken(provider);
+  } else if (isNodeBase(provider)) token = provider;
+  if (!token || !isNodeBase(token)) {
+    if (isAlias) throw InjectionError.invalidAlias(provider);
+    throw InjectionError.invalidProvider(JSON.stringify(provider));
+  }
+  return token;
+}
+__name(extractToken, "extractToken");
+
 // src/lib/errors.ts
 var ERR_CODES = {
   // Provider errors
@@ -101,92 +179,15 @@ function isNotFoundError(error) {
 }
 __name(isNotFoundError, "isNotFoundError");
 
-// src/lib/api/token.ts
-var NodeBase = class {
-  static {
-    __name(this, "NodeBase");
-  }
-  name;
-  opts;
-  constructor(name, opts) {
-    this.name = name;
-    this.opts = opts;
-  }
-  /** Provides this token with a value */
-  withValue(value) {
-    return {
-      provide: this,
-      value
-    };
-  }
-  /** Provides this token using a factory function */
-  withFactory(factory) {
-    return {
-      provide: this,
-      factory
-    };
-  }
-  /** Provides this token using a class constructor */
-  withClass(ctor) {
-    return {
-      provide: this,
-      useClass: ctor
-    };
-  }
-  /** Creates an alias to another token */
-  withAlias(alias) {
-    return {
-      provide: this,
-      alias
-    };
-  }
-  toString() {
-    return `Token[${this.name}]`;
-  }
-};
-var NodeToken = class extends NodeBase {
-  static {
-    __name(this, "NodeToken");
-  }
-  multi = false;
-  toString() {
-    return `NodeToken[${this.name}]`;
-  }
-};
-var MultiNodeToken = class extends NodeBase {
-  static {
-    __name(this, "MultiNodeToken");
-  }
-  multi = true;
-  toString() {
-    return `MultiNodeToken[${this.name}]`;
-  }
-};
-function isNodeBase(specimen) {
-  return specimen instanceof NodeToken || specimen instanceof MultiNodeToken;
-}
-__name(isNodeBase, "isNodeBase");
-function extractToken(provider, isAlias = false) {
-  let token = null;
-  if (isInjectable(provider)) {
-    token = getInjectableToken(provider);
-  } else if (isNodeBase(provider)) token = provider;
-  if (!token || !isNodeBase(token)) {
-    if (isAlias) throw InjectionError.invalidAlias(provider);
-    throw InjectionError.invalidProvider(JSON.stringify(provider));
-  }
-  return token;
-}
-__name(extractToken, "extractToken");
-
 // src/lib/api/decorator.ts
+var tokenRegistry = /* @__PURE__ */ new WeakMap();
 var INJECTION_SYMBOL = Symbol("Injectable");
 function NodeInjectable() {
   return (ctor) => {
     const nodeToken = new NodeToken(`_${ctor.name}`, {
       factory: /* @__PURE__ */ __name(() => new ctor(), "factory")
     });
-    ctor[INJECTION_SYMBOL] = nodeToken;
+    registerClassAsInjectable(ctor, nodeToken);
     return ctor;
   };
 }
@@ -195,22 +196,30 @@ function makeInjectable(ctor) {
   const nodeToken = new NodeToken(`_${ctor.name}`, {
     factory: /* @__PURE__ */ __name(() => new ctor(), "factory")
   });
-  ctor[INJECTION_SYMBOL] = nodeToken;
+  registerClassAsInjectable(ctor, nodeToken);
   return ctor;
 }
 __name(makeInjectable, "makeInjectable");
 function isInjectable(ctor) {
-  return typeof ctor === "function" && isConstructor(ctor) && INJECTION_SYMBOL in ctor && ctor[INJECTION_SYMBOL] instanceof NodeToken;
+  return typeof ctor === "function" && isConstructor(ctor) && (tokenRegistry.has(ctor) || INJECTION_SYMBOL in ctor);
 }
 __name(isInjectable, "isInjectable");
 function getInjectableToken(ctor) {
-  return ctor[INJECTION_SYMBOL];
+  if (tokenRegistry.has(ctor)) return tokenRegistry.get(ctor);
+  if (INJECTION_SYMBOL in ctor) {
+    return ctor[INJECTION_SYMBOL];
+  }
+  throw InjectionError.invalidCtor(ctor);
 }
 __name(getInjectableToken, "getInjectableToken");
 function isConstructor(fn) {
   return typeof fn === "function" && fn.prototype && fn.prototype.constructor === fn;
 }
 __name(isConstructor, "isConstructor");
+function registerClassAsInjectable(ctor, token) {
+  tokenRegistry.set(ctor, token);
+}
+__name(registerClassAsInjectable, "registerClassAsInjectable");
 
 // src/lib/plugins/core/plugin-container.ts
 var Illuma = class _Illuma {
@@ -464,7 +473,7 @@ var TreeRootNode = class {
   }
   instant;
   _deps = /* @__PURE__ */ new Set();
-  _treePool = /* @__PURE__ */ new Map();
+  _treePool = /* @__PURE__ */ new WeakMap();
   constructor(instant = true) {
     this.instant = instant;
   }
@@ -1126,6 +1135,7 @@ export {
   isInjectable,
   isNodeBase,
   makeInjectable,
-  nodeInject
+  nodeInject,
+  registerClassAsInjectable
 };
 //# sourceMappingURL=index.js.map