@decaf-ts/injectable-decorators 1.6.3 → 1.6.4

package/lib/decorators.d.ts

@@ -1,3 +1,13 @@
+import { InstanceCallback } from "./types";
+/**
+ * @description Generates a fully qualified reflection metadata key.
+ * @summary Returns the reflection key for injectables by prefixing the provided key with the base reflection key.
+ * @param {string} key The key to be prefixed
+ * @return {string} The fully qualified reflection key
+ * @function getInjectKey
+ * @memberOf module:injectable-decorators
+ */
+export declare const getInjectKey: (key: string) => string;
 /**
  * @description Decorator that marks a class as available for dependency injection.
  * @summary Defines a class as an injectable singleton that can be retrieved from the registry.
@@ -37,7 +47,7 @@
  *   Decorator->>Decorator: Define metadata
  *   Decorator-->>Client: Return instance
  */
-export declare function injectable(category?: string | undefined, force?: boolean, instanceCallback?: (instance: any, ...args: any[]) => void): (original: any, propertyKey?: any) => any;
+export declare function injectable(category?: string | undefined, instanceCallback?: InstanceCallback<any>): (original: any) => any;
 /**
  * @description Function type for transforming injectable instances before they're injected.
  * @summary Function which transforms a cached {@link injectable} instance before it's injected into a target object.
@@ -109,4 +119,6 @@ export type InstanceTransformer = (injectable: any, obj: any) => any;
  *     end
  *   end
  */
-export declare function inject(category?: string, transformer?: InstanceTransformer): (target: any, propertyKey?: any) => void;
+export declare function inject(category?: symbol | string | {
+    new (...args: any[]): any;
+}, transformer?: InstanceTransformer): (target: any, propertyKey?: any) => void;

package/lib/esm/Injectables.d.ts

@@ -53,7 +53,9 @@ export declare class Injectables {
      * @param {any[]} args Constructor arguments to pass when instantiating the injectable
      * @return {Injectable<T> | undefined} The injectable instance or undefined if not found
      */
-    static get<T>(name: string, ...args: any[]): Injectable<T> | undefined;
+    static get<T>(name: symbol | string | {
+        new (...args: any[]): T;
+    }, ...args: any[]): T | undefined;
     /**
      * @description Adds a class or object to the injectable registry.
      * @summary Registers an injectable constructor or instance with the registry, making it available for injection.
@@ -67,11 +69,11 @@ export declare class Injectables {
      * @description Creates a new instance of an injectable class.
      * @summary Instantiates an injectable class using its constructor and the provided arguments.
      * @template T Type of the object to build
-     * @param {Record<string, any>} obj Object containing the name of the injectable to build
+     * @param {symbol} name symbol referencing the injectable
      * @param {any[]} args Constructor arguments to pass when instantiating the injectable
      * @return {T} The newly created instance
      */
-    static build<T>(obj: Record<string, any>, ...args: any[]): T;
+    static build<T>(name: symbol, ...args: any[]): T;
     /**
      * @description Replaces the current registry implementation.
      * @summary Sets a new {@link InjectablesRegistry} implementation, allowing for custom registry behavior.

package/lib/esm/Injectables.js

@@ -71,12 +71,12 @@ export class Injectables {
      * @description Creates a new instance of an injectable class.
      * @summary Instantiates an injectable class using its constructor and the provided arguments.
      * @template T Type of the object to build
-     * @param {Record<string, any>} obj Object containing the name of the injectable to build
+     * @param {symbol} name symbol referencing the injectable
      * @param {any[]} args Constructor arguments to pass when instantiating the injectable
      * @return {T} The newly created instance
      */
-    static build(obj, ...args) {
-        return Injectables.getRegistry().build(obj, ...args);
+    static build(name, ...args) {
+        return Injectables.getRegistry().build(name, ...args);
     }
     /**
      * @description Replaces the current registry implementation.
@@ -120,4 +120,4 @@ export class Injectables {
         }, {});
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Injectables.js","sourceRoot":"","sources":["../../src/Injectables.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,GAEtB,sBAAmB;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,OAAO,WAAW;aACP,8BAAyB,GAAyB,SAAS,CAAC;IAE3E,gBAAuB,CAAC;IAExB;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAI,IAAY,EAAE,GAAG,IAAW;QACxC,OAAO,WAAW,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,CAAI,WAA0B,EAAE,GAAG,IAAW;QAC3D,OAAO,WAAW,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAI,GAAwB,EAAE,GAAG,IAAW;QACtD,OAAO,WAAW,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,kBAAuC;QACxD,WAAW,CAAC,yBAAyB,GAAG,kBAAkB,CAAC;IAC7D,CAAC;IACD;;;;OAIG;IACK,MAAM,CAAC,WAAW;QACxB,IAAI,CAAC,WAAW,CAAC,yBAAyB;YACxC,WAAW,CAAC,yBAAyB,GAAG,IAAI,qBAAqB,EAAE,CAAC;QACtE,OAAO,WAAW,CAAC,yBAAyB,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK;QACV,WAAW,CAAC,WAAW,CAAC,IAAI,qBAAqB,EAAE,CAAC,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,KAAsB;QAC1C,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACpE,WAAW,CAAC,yBAAiC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,CACrE,WAAW,CAAC,yBAAiC,CAAC,OAAO,CAAC,CACxD,CAAC,MAAM,CAAC,CAAC,KAA0B,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;YAClD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;YACzC,OAAO,KAAK,CAAC;QACf,CAAC,EAAE,EAAE,CAAC,CAAC;IACT,CAAC","sourcesContent":["import {\n  Injectable,\n  InjectableRegistryImp,\n  InjectablesRegistry,\n} from \"./registry\";\n\n/**\n * @description Central registry for managing injectable dependencies.\n * @summary Static class holding the access to the injectables functions. Provides methods for registering,\n * retrieving, and building injectable objects.\n * @template T Type of the injectable object\n * \n * @class Injectables\n * \n * @example\n * // Define an injectable class\n * @injectable()\n * class MyService {\n *   doSomething() {\n *     return 'Hello World';\n *   }\n * }\n * \n * // Inject the service into another class\n * class MyComponent {\n *   @inject()\n *   private service!: MyService;\n *   \n *   useService() {\n *     return this.service.doSomething();\n *   }\n * }\n * \n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Injectables\n *   participant Registry\n *   \n *   Client->>Injectables: register(MyService)\n *   Injectables->>Registry: register(MyService)\n *   Registry-->>Injectables: void\n *   \n *   Client->>Injectables: get(\"MyService\")\n *   Injectables->>Registry: get(\"MyService\")\n *   Registry-->>Injectables: MyService instance\n *   Injectables-->>Client: MyService instance\n */\nexport class Injectables {\n  private static actingInjectablesRegistry?: InjectablesRegistry = undefined;\n\n  private constructor() {}\n\n  /**\n   * @description Fetches an injectable instance by its registered name.\n   * @summary Retrieves the named {@link Injectable} from the registry. If the injectable is a singleton,\n   * returns the existing instance. Otherwise, creates a new instance.\n   * @template T Type of the injectable object to retrieve\n   * @param {string} name The registered name of the injectable to retrieve\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {Injectable<T> | undefined} The injectable instance or undefined if not found\n   */\n  static get<T>(name: string, ...args: any[]): Injectable<T> | undefined {\n    return Injectables.getRegistry().get(name, ...args);\n  }\n\n  /**\n   * @description Adds a class or object to the injectable registry.\n   * @summary Registers an injectable constructor or instance with the registry, making it available for injection.\n   * @template T Type of the injectable object to register\n   * @param {Injectable<T>} constructor The class constructor or object instance to register\n   * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)\n   * @return {void}\n   */\n  static register<T>(constructor: Injectable<T>, ...args: any[]): void {\n    return Injectables.getRegistry().register(constructor, ...args);\n  }\n\n  /**\n   * @description Creates a new instance of an injectable class.\n   * @summary Instantiates an injectable class using its constructor and the provided arguments.\n   * @template T Type of the object to build\n   * @param {Record<string, any>} obj Object containing the name of the injectable to build\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {T} The newly created instance\n   */\n  static build<T>(obj: Record<string, any>, ...args: any[]): T {\n    return Injectables.getRegistry().build(obj, ...args);\n  }\n\n  /**\n   * @description Replaces the current registry implementation.\n   * @summary Sets a new {@link InjectablesRegistry} implementation, allowing for custom registry behavior.\n   * @param {InjectablesRegistry} operationsRegistry The new implementation of Registry to use\n   * @return {void}\n   */\n  static setRegistry(operationsRegistry: InjectablesRegistry) {\n    Injectables.actingInjectablesRegistry = operationsRegistry;\n  }\n  /**\n   * @description Provides access to the current registry instance.\n   * @summary Returns the current {@link InjectablesRegistry} or creates a default one if none exists.\n   * @return {InjectablesRegistry} The current registry instance\n   */\n  private static getRegistry() {\n    if (!Injectables.actingInjectablesRegistry)\n      Injectables.actingInjectablesRegistry = new InjectableRegistryImp();\n    return Injectables.actingInjectablesRegistry;\n  }\n\n  /**\n   * @description Clears all registered injectables.\n   * @summary Resets the registry to a clean state by creating a new empty registry instance.\n   * @return {void}\n   */\n  static reset() {\n    Injectables.setRegistry(new InjectableRegistryImp());\n  }\n\n  /**\n   * @description Removes specific injectables from the registry based on a pattern.\n   * @summary Selectively resets the registry by removing only the injectables whose names match the provided pattern.\n   * @param {string | RegExp} match A string or regular expression pattern to match against injectable names\n   * @return {void}\n   */\n  static selectiveReset(match: string | RegExp) {\n    const regexp = typeof match === \"string\" ? new RegExp(match) : match;\n    (Injectables.actingInjectablesRegistry as any)[\"cache\"] = Object.entries(\n      (Injectables.actingInjectablesRegistry as any)[\"cache\"]\n    ).reduce((accum: Record<string, any>, [key, val]) => {\n      if (!key.match(regexp)) accum[key] = val;\n      return accum;\n    }, {});\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Injectables.js","sourceRoot":"","sources":["../../src/Injectables.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,GAEtB,sBAAmB;AAGpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,OAAO,WAAW;aACP,8BAAyB,GAAyB,SAAS,CAAC;IAE3E,gBAAuB,CAAC;IAExB;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CACR,IAAmD,EACnD,GAAG,IAAW;QAEd,OAAO,WAAW,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,CAAI,WAA0B,EAAE,GAAG,IAAW;QAC3D,OAAO,WAAW,CAAC,WAAW,EAAE,CAAC,QAAQ,CACvC,WAAW,EACX,GAAI,IAAuC,CAC5C,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAI,IAAY,EAAE,GAAG,IAAW;QAC1C,OAAO,WAAW,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;IACxD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,kBAAuC;QACxD,WAAW,CAAC,yBAAyB,GAAG,kBAAkB,CAAC;IAC7D,CAAC;IACD;;;;OAIG;IACK,MAAM,CAAC,WAAW;QACxB,IAAI,CAAC,WAAW,CAAC,yBAAyB;YACxC,WAAW,CAAC,yBAAyB,GAAG,IAAI,qBAAqB,EAAE,CAAC;QACtE,OAAO,WAAW,CAAC,yBAAyB,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK;QACV,WAAW,CAAC,WAAW,CAAC,IAAI,qBAAqB,EAAE,CAAC,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,KAAsB;QAC1C,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACpE,WAAW,CAAC,yBAAiC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,CACrE,WAAW,CAAC,yBAAiC,CAAC,OAAO,CAAC,CACxD,CAAC,MAAM,CAAC,CAAC,KAA0B,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;YAClD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;YACzC,OAAO,KAAK,CAAC;QACf,CAAC,EAAE,EAAE,CAAC,CAAC;IACT,CAAC","sourcesContent":["import {\n  Injectable,\n  InjectableRegistryImp,\n  InjectablesRegistry,\n} from \"./registry\";\nimport { InjectableOptions } from \"./types\";\n\n/**\n * @description Central registry for managing injectable dependencies.\n * @summary Static class holding the access to the injectables functions. Provides methods for registering,\n * retrieving, and building injectable objects.\n * @template T Type of the injectable object\n *\n * @class Injectables\n *\n * @example\n * // Define an injectable class\n * @injectable()\n * class MyService {\n *   doSomething() {\n *     return 'Hello World';\n *   }\n * }\n *\n * // Inject the service into another class\n * class MyComponent {\n *   @inject()\n *   private service!: MyService;\n *\n *   useService() {\n *     return this.service.doSomething();\n *   }\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Injectables\n *   participant Registry\n *\n *   Client->>Injectables: register(MyService)\n *   Injectables->>Registry: register(MyService)\n *   Registry-->>Injectables: void\n *\n *   Client->>Injectables: get(\"MyService\")\n *   Injectables->>Registry: get(\"MyService\")\n *   Registry-->>Injectables: MyService instance\n *   Injectables-->>Client: MyService instance\n */\nexport class Injectables {\n  private static actingInjectablesRegistry?: InjectablesRegistry = undefined;\n\n  private constructor() {}\n\n  /**\n   * @description Fetches an injectable instance by its registered name.\n   * @summary Retrieves the named {@link Injectable} from the registry. If the injectable is a singleton,\n   * returns the existing instance. Otherwise, creates a new instance.\n   * @template T Type of the injectable object to retrieve\n   * @param {string} name The registered name of the injectable to retrieve\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {Injectable<T> | undefined} The injectable instance or undefined if not found\n   */\n  static get<T>(\n    name: symbol | string | { new (...args: any[]): T },\n    ...args: any[]\n  ): T | undefined {\n    return Injectables.getRegistry().get(name, ...args);\n  }\n\n  /**\n   * @description Adds a class or object to the injectable registry.\n   * @summary Registers an injectable constructor or instance with the registry, making it available for injection.\n   * @template T Type of the injectable object to register\n   * @param {Injectable<T>} constructor The class constructor or object instance to register\n   * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)\n   * @return {void}\n   */\n  static register<T>(constructor: Injectable<T>, ...args: any[]): void {\n    return Injectables.getRegistry().register(\n      constructor,\n      ...(args as [symbol, InjectableOptions<T>])\n    );\n  }\n\n  /**\n   * @description Creates a new instance of an injectable class.\n   * @summary Instantiates an injectable class using its constructor and the provided arguments.\n   * @template T Type of the object to build\n   * @param {symbol} name symbol referencing the injectable\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {T} The newly created instance\n   */\n  static build<T>(name: symbol, ...args: any[]): T {\n    return Injectables.getRegistry().build(name, ...args);\n  }\n\n  /**\n   * @description Replaces the current registry implementation.\n   * @summary Sets a new {@link InjectablesRegistry} implementation, allowing for custom registry behavior.\n   * @param {InjectablesRegistry} operationsRegistry The new implementation of Registry to use\n   * @return {void}\n   */\n  static setRegistry(operationsRegistry: InjectablesRegistry): void {\n    Injectables.actingInjectablesRegistry = operationsRegistry;\n  }\n  /**\n   * @description Provides access to the current registry instance.\n   * @summary Returns the current {@link InjectablesRegistry} or creates a default one if none exists.\n   * @return {InjectablesRegistry} The current registry instance\n   */\n  private static getRegistry(): InjectablesRegistry {\n    if (!Injectables.actingInjectablesRegistry)\n      Injectables.actingInjectablesRegistry = new InjectableRegistryImp();\n    return Injectables.actingInjectablesRegistry;\n  }\n\n  /**\n   * @description Clears all registered injectables.\n   * @summary Resets the registry to a clean state by creating a new empty registry instance.\n   * @return {void}\n   */\n  static reset(): void {\n    Injectables.setRegistry(new InjectableRegistryImp());\n  }\n\n  /**\n   * @description Removes specific injectables from the registry based on a pattern.\n   * @summary Selectively resets the registry by removing only the injectables whose names match the provided pattern.\n   * @param {string | RegExp} match A string or regular expression pattern to match against injectable names\n   * @return {void}\n   */\n  static selectiveReset(match: string | RegExp): void {\n    const regexp = typeof match === \"string\" ? new RegExp(match) : match;\n    (Injectables.actingInjectablesRegistry as any)[\"cache\"] = Object.entries(\n      (Injectables.actingInjectablesRegistry as any)[\"cache\"]\n    ).reduce((accum: Record<string, any>, [key, val]) => {\n      if (!key.match(regexp)) accum[key] = val;\n      return accum;\n    }, {});\n  }\n}\n"]}

package/lib/esm/decorators.d.ts

@@ -1,3 +1,13 @@
+import { InstanceCallback } from "./types";
+/**
+ * @description Generates a fully qualified reflection metadata key.
+ * @summary Returns the reflection key for injectables by prefixing the provided key with the base reflection key.
+ * @param {string} key The key to be prefixed
+ * @return {string} The fully qualified reflection key
+ * @function getInjectKey
+ * @memberOf module:injectable-decorators
+ */
+export declare const getInjectKey: (key: string) => string;
 /**
  * @description Decorator that marks a class as available for dependency injection.
  * @summary Defines a class as an injectable singleton that can be retrieved from the registry.
@@ -37,7 +47,7 @@
  *   Decorator->>Decorator: Define metadata
  *   Decorator-->>Client: Return instance
  */
-export declare function injectable(category?: string | undefined, force?: boolean, instanceCallback?: (instance: any, ...args: any[]) => void): (original: any, propertyKey?: any) => any;
+export declare function injectable(category?: string | undefined, instanceCallback?: InstanceCallback<any>): (original: any) => any;
 /**
  * @description Function type for transforming injectable instances before they're injected.
  * @summary Function which transforms a cached {@link injectable} instance before it's injected into a target object.
@@ -109,4 +119,6 @@ export type InstanceTransformer = (injectable: any, obj: any) => any;
  *     end
  *   end
  */
-export declare function inject(category?: string, transformer?: InstanceTransformer): (target: any, propertyKey?: any) => void;
+export declare function inject(category?: symbol | string | {
+    new (...args: any[]): any;
+}, transformer?: InstanceTransformer): (target: any, propertyKey?: any) => void;

package/lib/esm/decorators.js

@@ -9,7 +9,7 @@ import { getTypeFromDecorator } from "./utils.js";
  * @function getInjectKey
  * @memberOf module:injectable-decorators
  */
-const getInjectKey = (key) => InjectablesKeys.REFLECT + key;
+export const getInjectKey = (key) => InjectablesKeys.REFLECT + key;
 /**
  * @description Decorator that marks a class as available for dependency injection.
  * @summary Defines a class as an injectable singleton that can be retrieved from the registry.
@@ -49,20 +49,18 @@ const getInjectKey = (key) => InjectablesKeys.REFLECT + key;
  *   Decorator->>Decorator: Define metadata
  *   Decorator-->>Client: Return instance
  */
-export function injectable(category = undefined, force = false, instanceCallback) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    return (original, propertyKey) => {
+export function injectable(category = undefined, instanceCallback) {
+    return (original) => {
+        const symbol = Symbol.for(category || original.toString());
         const name = category || original.name;
+        const metadata = {
+            class: name,
+            symbol: symbol,
+        };
+        Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECTABLE), metadata, original);
         // the new constructor behaviour
         const newConstructor = function (...args) {
-            const inj = Injectables.get(name, ...args);
-            if (!inj)
-                return undefined;
-            const metadata = Object.assign({}, {
-                class: name,
-            });
-            Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECTABLE), metadata, inj.constructor);
-            return inj;
+            return Injectables.get(symbol, ...args);
         };
         // copy prototype so instanceof operator still works
         newConstructor.prototype = original.prototype;
@@ -74,7 +72,12 @@ export function injectable(category = undefined, force = false, instanceCallback
             configurable: false,
             value: original.prototype.constructor.name,
         });
-        Injectables.register(newConstructor, name, true, force);
+        const opts = {
+            singleton: true,
+            callback: instanceCallback,
+        };
+        Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECTABLE), metadata, newConstructor);
+        Injectables.register(original, symbol, opts);
         // return new constructor (will override original)
         return newConstructor;
     };
@@ -141,9 +144,14 @@ export function injectable(category = undefined, force = false, instanceCallback
 export function inject(category, transformer) {
     return (target, propertyKey) => {
         const values = new WeakMap();
-        const name = category || getTypeFromDecorator(target, propertyKey);
-        if (!name)
+        const name = category
+            ? typeof category === "symbol"
+                ? category
+                : Symbol.for(category.toString())
+            : getTypeFromDecorator(target, propertyKey);
+        if (!name) {
             throw new Error(`Could not get Type from decorator`);
+        }
         Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECT), {
             injectable: name,
         }, target, propertyKey);
@@ -160,7 +168,7 @@ export function inject(category, transformer) {
                             if (!obj) {
                                 obj = Injectables.get(name);
                                 if (!obj)
-                                    throw new Error(`Could not get Injectable ${name} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`);
+                                    throw new Error(`Could not get Injectable ${name.toString()} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`);
                                 if (transformer)
                                     try {
                                         obj = transformer(obj, target);
@@ -179,4 +187,4 @@ export function inject(category, transformer) {
         });
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { InjectablesKeys } from \"./constants\";\nimport { Injectables } from \"./Injectables\";\nimport { getTypeFromDecorator } from \"./utils\";\n\n/**\n * @description Generates a fully qualified reflection metadata key.\n * @summary Returns the reflection key for injectables by prefixing the provided key with the base reflection key.\n * @param {string} key The key to be prefixed\n * @return {string} The fully qualified reflection key\n * @function getInjectKey\n * @memberOf module:injectable-decorators\n */\nconst getInjectKey = (key: string) => InjectablesKeys.REFLECT + key;\n\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable singleton that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns a singleton instance.\n *\n * @param {string} [category] Defaults to the class name. Useful when minification occurs and names are changed,\n * or when you want to upcast the object to a different type.\n * @param {boolean} [force] Defines if the injectable should override an already existing instance (if any).\n * Only meant for extending decorators.\n * @param {Function} [instanceCallback] Optional callback function that will be called with the instance after creation.\n * @return {Function} A decorator function that transforms the class into an injectable.\n *\n * @function injectable\n * @category Class Decorators\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator\n *   participant Injectables\n *\n *   Client->>Decorator: @injectable()\n *   Decorator->>Decorator: Create new constructor\n *\n *   Note over Decorator: When new instance requested\n *   Decorator->>Injectables: get(name)\n *   alt Instance exists\n *     Injectables-->>Decorator: Return existing instance\n *   else No instance\n *     Decorator->>Injectables: register(original, name)\n *     Decorator->>Injectables: get(name)\n *     Injectables-->>Decorator: Return new instance\n *     opt Has callback\n *       Decorator->>Decorator: Call instanceCallback\n *     end\n *   end\n *   Decorator->>Decorator: Define metadata\n *   Decorator-->>Client: Return instance\n */\nexport function injectable(\n  category: string | undefined = undefined,\n  force: boolean = false,\n  instanceCallback?: (instance: any, ...args: any[]) => void\n) {\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  return (original: any, propertyKey?: any) => {\n    const name = category || original.name;\n    // the new constructor behaviour\n    const newConstructor: any = function (...args: any[]) {\n      const inj: any = Injectables.get<any>(name, ...args);\n      if (!inj) return undefined;\n\n      const metadata = Object.assign(\n        {},\n        {\n          class: name,\n        }\n      );\n\n      Reflect.defineMetadata(\n        getInjectKey(InjectablesKeys.INJECTABLE),\n        metadata,\n        inj.constructor\n      );\n\n      return inj;\n    };\n\n    // copy prototype so instanceof operator still works\n    newConstructor.prototype = original.prototype;\n    // newConstructor.__proto__ = original.__proto__;\n    // Sets the proper constructor name for type verification\n    Object.defineProperty(newConstructor, \"name\", {\n      writable: false,\n      enumerable: true,\n      configurable: false,\n      value: original.prototype.constructor.name,\n    });\n\n    Injectables.register(newConstructor, name, true, force);\n    // return new constructor (will override original)\n    return newConstructor;\n  };\n}\n/**\n * @description Function type for transforming injectable instances before they're injected.\n * @summary Function which transforms a cached {@link injectable} instance before it's injected into a target object.\n *\n * @param {any} injectable The injectable instance to transform\n * @param {any} obj The object the injectable will be injected on\n * @return {any} The transformed injectable instance\n *\n * @typedef {Function} InstanceTransformer\n * @memberOf module:injectable-decorators\n */\nexport type InstanceTransformer = (injectable: any, obj: any) => any;\n\n/**\n * @description Property decorator that injects a dependency into a class property.\n * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.\n * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.\n *\n * Injected properties should be described like so:\n * <pre>\n *     class ClassName {\n *         ...\n *\n *         @inject()\n *         propertyName!: InjectableClass;\n *\n *         ...\n *     }\n * </pre>\n *\n * where InjectableClass is the class you want to inject.\n * Notice the use of '!:' to ensure the transpiler the property will be set outside the constructor but will always be defined.\n * For projects where minification occurs, you should use the category param to ensure the name is the same throughout.\n *\n * @param {string} [category] Defaults to the class name derived from the property type. Useful when minification occurs\n * and names are changed, or when you want to upcast the object to a different type.\n * @param {InstanceTransformer} [transformer] Optional function to transform the injectable instance before it's injected.\n * @return {Function} A property decorator function that sets up the dependency injection.\n *\n * @function inject\n * @category Property Decorators\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator\n *   participant Injectables\n *\n *   Client->>Decorator: @inject()\n *   Decorator->>Decorator: Get type from property\n *   Decorator->>Decorator: Define metadata\n *   Decorator->>Decorator: Define property getter\n *\n *   Note over Decorator: When property accessed\n *   Client->>Decorator: access property\n *   Decorator->>Decorator: Check if instance exists\n *   alt Instance exists in WeakMap\n *     Decorator-->>Client: Return cached instance\n *   else No instance\n *     Decorator->>Injectables: get(name)\n *     alt Injectable found\n *       Injectables-->>Decorator: Return injectable instance\n *       opt Has transformer\n *         Decorator->>Decorator: Call transformer\n *       end\n *       Decorator->>Decorator: Store in WeakMap\n *       Decorator-->>Client: Return instance\n *     else No injectable\n *       Decorator-->>Client: Throw error\n *     end\n *   end\n */\nexport function inject(category?: string, transformer?: InstanceTransformer) {\n  return (target: any, propertyKey?: any) => {\n    const values = new WeakMap();\n\n    const name: string | undefined =\n      category || getTypeFromDecorator(target, propertyKey);\n    if (!name) throw new Error(`Could not get Type from decorator`);\n\n    Reflect.defineMetadata(\n      getInjectKey(InjectablesKeys.INJECT),\n      {\n        injectable: name,\n      },\n      target,\n      propertyKey\n    );\n\n    Object.defineProperty(target, propertyKey, {\n      configurable: true,\n      get(this: any) {\n        const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(\n          target,\n          propertyKey\n        ) as PropertyDescriptor;\n        if (descriptor.configurable) {\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get(this: any) {\n              let obj = values.get(this);\n              if (!obj) {\n                obj = Injectables.get(name);\n                if (!obj)\n                  throw new Error(\n                    `Could not get Injectable ${name} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`\n                  );\n                if (transformer)\n                  try {\n                    obj = transformer(obj, target);\n                  } catch (e) {\n                    console.error(e);\n                  }\n                values.set(this, obj);\n              }\n              return obj;\n            },\n          });\n          return this[propertyKey];\n        }\n      },\n    });\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,uBAAoB;AAC9C,OAAO,EAAE,WAAW,EAAE,yBAAsB;AAC5C,OAAO,EAAE,oBAAoB,EAAE,mBAAgB;AAO/C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,eAAe,CAAC,OAAO,GAAG,GAAG,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,UAAU,CACxB,WAA+B,SAAS,EACxC,gBAAwC;IAExC,OAAO,CAAC,QAAa,EAAE,EAAE;QACvB,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC3D,MAAM,IAAI,GAAG,QAAQ,IAAI,QAAQ,CAAC,IAAI,CAAC;QAEvC,MAAM,QAAQ,GAAuB;YACnC,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,MAAM;SACf,CAAC;QAEF,OAAO,CAAC,cAAc,CACpB,YAAY,CAAC,eAAe,CAAC,UAAU,CAAC,EACxC,QAAQ,EACR,QAAQ,CACT,CAAC;QACF,gCAAgC;QAChC,MAAM,cAAc,GAAQ,UAAU,GAAG,IAAW;YAClD,OAAO,WAAW,CAAC,GAAG,CAAM,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;QAC/C,CAAC,CAAC;QAEF,oDAAoD;QACpD,cAAc,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;QAC9C,iDAAiD;QACjD,yDAAyD;QACzD,MAAM,CAAC,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE;YAC5C,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,KAAK;YACnB,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI;SAC3C,CAAC,CAAC;QAEH,MAAM,IAAI,GAA2B;YACnC,SAAS,EAAE,IAAI;YACf,QAAQ,EAAE,gBAAyC;SACpD,CAAC;QAEF,OAAO,CAAC,cAAc,CACpB,YAAY,CAAC,eAAe,CAAC,UAAU,CAAC,EACxC,QAAQ,EACR,cAAc,CACf,CAAC;QAEF,WAAW,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;QAC7C,kDAAkD;QAClD,OAAO,cAAc,CAAC;IACxB,CAAC,CAAC;AACJ,CAAC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,UAAU,MAAM,CACpB,QAA0D,EAC1D,WAAiC;IAEjC,OAAO,CAAC,MAAW,EAAE,WAAiB,EAAE,EAAE;QACxC,MAAM,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAE7B,MAAM,IAAI,GAAuB,QAAQ;YACvC,CAAC,CAAC,OAAO,QAAQ,KAAK,QAAQ;gBAC5B,CAAC,CAAC,QAAQ;gBACV,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACnC,CAAC,CAAC,oBAAoB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QAC9C,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QAED,OAAO,CAAC,cAAc,CACpB,YAAY,CAAC,eAAe,CAAC,MAAM,CAAC,EACpC;YACE,UAAU,EAAE,IAAI;SACjB,EACD,MAAM,EACN,WAAW,CACZ,CAAC;QAEF,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YACzC,YAAY,EAAE,IAAI;YAClB,GAAG;gBACD,MAAM,UAAU,GAAuB,MAAM,CAAC,wBAAwB,CACpE,MAAM,EACN,WAAW,CACU,CAAC;gBACxB,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;oBAC5B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE;wBACvC,UAAU,EAAE,IAAI;wBAChB,YAAY,EAAE,KAAK;wBACnB,GAAG;4BACD,IAAI,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;4BAC3B,IAAI,CAAC,GAAG,EAAE,CAAC;gCACT,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gCAC5B,IAAI,CAAC,GAAG;oCACN,MAAM,IAAI,KAAK,CACb,4BAA4B,IAAI,CAAC,QAAQ,EAAE,iBAAiB,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,MAAM,WAAW,EAAE,CAC1I,CAAC;gCACJ,IAAI,WAAW;oCACb,IAAI,CAAC;wCACH,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;oCACjC,CAAC;oCAAC,OAAO,CAAC,EAAE,CAAC;wCACX,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oCACnB,CAAC;gCACH,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;4BACxB,CAAC;4BACD,OAAO,GAAG,CAAC;wBACb,CAAC;qBACF,CAAC,CAAC;oBACH,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC;gBAC3B,CAAC;YACH,CAAC;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { InjectablesKeys } from \"./constants\";\nimport { Injectables } from \"./Injectables\";\nimport { getTypeFromDecorator } from \"./utils\";\nimport {\n  InjectableMetadata,\n  InjectableOptions,\n  InstanceCallback,\n} from \"./types\";\n\n/**\n * @description Generates a fully qualified reflection metadata key.\n * @summary Returns the reflection key for injectables by prefixing the provided key with the base reflection key.\n * @param {string} key The key to be prefixed\n * @return {string} The fully qualified reflection key\n * @function getInjectKey\n * @memberOf module:injectable-decorators\n */\nexport const getInjectKey = (key: string) => InjectablesKeys.REFLECT + key;\n\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable singleton that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns a singleton instance.\n *\n * @param {string} [category] Defaults to the class name. Useful when minification occurs and names are changed,\n * or when you want to upcast the object to a different type.\n * @param {boolean} [force] Defines if the injectable should override an already existing instance (if any).\n * Only meant for extending decorators.\n * @param {Function} [instanceCallback] Optional callback function that will be called with the instance after creation.\n * @return {Function} A decorator function that transforms the class into an injectable.\n *\n * @function injectable\n * @category Class Decorators\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator\n *   participant Injectables\n *\n *   Client->>Decorator: @injectable()\n *   Decorator->>Decorator: Create new constructor\n *\n *   Note over Decorator: When new instance requested\n *   Decorator->>Injectables: get(name)\n *   alt Instance exists\n *     Injectables-->>Decorator: Return existing instance\n *   else No instance\n *     Decorator->>Injectables: register(original, name)\n *     Decorator->>Injectables: get(name)\n *     Injectables-->>Decorator: Return new instance\n *     opt Has callback\n *       Decorator->>Decorator: Call instanceCallback\n *     end\n *   end\n *   Decorator->>Decorator: Define metadata\n *   Decorator-->>Client: Return instance\n */\nexport function injectable(\n  category: string | undefined = undefined,\n  instanceCallback?: InstanceCallback<any>\n) {\n  return (original: any) => {\n    const symbol = Symbol.for(category || original.toString());\n    const name = category || original.name;\n\n    const metadata: InjectableMetadata = {\n      class: name,\n      symbol: symbol,\n    };\n\n    Reflect.defineMetadata(\n      getInjectKey(InjectablesKeys.INJECTABLE),\n      metadata,\n      original\n    );\n    // the new constructor behaviour\n    const newConstructor: any = function (...args: any[]) {\n      return Injectables.get<any>(symbol, ...args);\n    };\n\n    // copy prototype so instanceof operator still works\n    newConstructor.prototype = original.prototype;\n    // newConstructor.__proto__ = original.__proto__;\n    // Sets the proper constructor name for type verification\n    Object.defineProperty(newConstructor, \"name\", {\n      writable: false,\n      enumerable: true,\n      configurable: false,\n      value: original.prototype.constructor.name,\n    });\n\n    const opts: InjectableOptions<any> = {\n      singleton: true,\n      callback: instanceCallback as InstanceCallback<any>,\n    };\n\n    Reflect.defineMetadata(\n      getInjectKey(InjectablesKeys.INJECTABLE),\n      metadata,\n      newConstructor\n    );\n\n    Injectables.register(original, symbol, opts);\n    // return new constructor (will override original)\n    return newConstructor;\n  };\n}\n/**\n * @description Function type for transforming injectable instances before they're injected.\n * @summary Function which transforms a cached {@link injectable} instance before it's injected into a target object.\n *\n * @param {any} injectable The injectable instance to transform\n * @param {any} obj The object the injectable will be injected on\n * @return {any} The transformed injectable instance\n *\n * @typedef {Function} InstanceTransformer\n * @memberOf module:injectable-decorators\n */\nexport type InstanceTransformer = (injectable: any, obj: any) => any;\n\n/**\n * @description Property decorator that injects a dependency into a class property.\n * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.\n * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.\n *\n * Injected properties should be described like so:\n * <pre>\n *     class ClassName {\n *         ...\n *\n *         @inject()\n *         propertyName!: InjectableClass;\n *\n *         ...\n *     }\n * </pre>\n *\n * where InjectableClass is the class you want to inject.\n * Notice the use of '!:' to ensure the transpiler the property will be set outside the constructor but will always be defined.\n * For projects where minification occurs, you should use the category param to ensure the name is the same throughout.\n *\n * @param {string} [category] Defaults to the class name derived from the property type. Useful when minification occurs\n * and names are changed, or when you want to upcast the object to a different type.\n * @param {InstanceTransformer} [transformer] Optional function to transform the injectable instance before it's injected.\n * @return {Function} A property decorator function that sets up the dependency injection.\n *\n * @function inject\n * @category Property Decorators\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator\n *   participant Injectables\n *\n *   Client->>Decorator: @inject()\n *   Decorator->>Decorator: Get type from property\n *   Decorator->>Decorator: Define metadata\n *   Decorator->>Decorator: Define property getter\n *\n *   Note over Decorator: When property accessed\n *   Client->>Decorator: access property\n *   Decorator->>Decorator: Check if instance exists\n *   alt Instance exists in WeakMap\n *     Decorator-->>Client: Return cached instance\n *   else No instance\n *     Decorator->>Injectables: get(name)\n *     alt Injectable found\n *       Injectables-->>Decorator: Return injectable instance\n *       opt Has transformer\n *         Decorator->>Decorator: Call transformer\n *       end\n *       Decorator->>Decorator: Store in WeakMap\n *       Decorator-->>Client: Return instance\n *     else No injectable\n *       Decorator-->>Client: Throw error\n *     end\n *   end\n */\nexport function inject(\n  category?: symbol | string | { new (...args: any[]): any },\n  transformer?: InstanceTransformer\n) {\n  return (target: any, propertyKey?: any) => {\n    const values = new WeakMap();\n\n    const name: symbol | undefined = category\n      ? typeof category === \"symbol\"\n        ? category\n        : Symbol.for(category.toString())\n      : getTypeFromDecorator(target, propertyKey);\n    if (!name) {\n      throw new Error(`Could not get Type from decorator`);\n    }\n\n    Reflect.defineMetadata(\n      getInjectKey(InjectablesKeys.INJECT),\n      {\n        injectable: name,\n      },\n      target,\n      propertyKey\n    );\n\n    Object.defineProperty(target, propertyKey, {\n      configurable: true,\n      get(this: any) {\n        const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(\n          target,\n          propertyKey\n        ) as PropertyDescriptor;\n        if (descriptor.configurable) {\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get(this: any) {\n              let obj = values.get(this);\n              if (!obj) {\n                obj = Injectables.get(name);\n                if (!obj)\n                  throw new Error(\n                    `Could not get Injectable ${name.toString()} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`\n                  );\n                if (transformer)\n                  try {\n                    obj = transformer(obj, target);\n                  } catch (e) {\n                    console.error(e);\n                  }\n                values.set(this, obj);\n              }\n              return obj;\n            },\n          });\n          return this[propertyKey];\n        }\n      },\n    });\n  };\n}\n"]}

package/lib/esm/index.d.ts

@@ -10,6 +10,7 @@ export * from "./constants";
 export * from "./decorators";
 export * from "./Injectables";
 export * from "./registry";
+export * from "./types";
 export * from "./utils";
 /**
  * @description Current version of the injectable-decorators library.
@@ -17,4 +18,4 @@ export * from "./utils";
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export declare const VERSION = "1.6.3";
+export declare const VERSION = "1.6.4";

package/lib/esm/index.js

@@ -10,6 +10,7 @@ export * from "./constants.js";
 export * from "./decorators.js";
 export * from "./Injectables.js";
 export * from "./registry.js";
+export * from "./types.js";
 export * from "./utils.js";
 /**
  * @description Current version of the injectable-decorators library.
@@ -17,5 +18,5 @@ export * from "./utils.js";
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export const VERSION = "1.6.3";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFDN0IsaUNBQThCO0FBQzlCLDhCQUEyQjtBQUMzQiwyQkFBd0I7QUFFeEI7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gQSBsaWdodHdlaWdodCBkZXBlbmRlbmN5IGluamVjdGlvbiBsaWJyYXJ5IGZvciBUeXBlU2NyaXB0IGFwcGxpY2F0aW9ucy5cbiAqIEBzdW1tYXJ5IEFkZHMgYSBzaW1wbGUgSW5qZWN0YWJsZXMgaW1wbGVtZW50YXRpb24gdG8gY3JlYXRlIHNpbmdsZXRvbiBpbnN0YW5jZXMgb2YgYW4gb2JqZWN0XG4gKiBhbmQgZWFzaWx5IGluamVjdCBpdCBpbnRvIG90aGVyIG9iamVjdHMuIFByb3ZpZGVzIGRlY29yYXRvcnMgZm9yIG1hcmtpbmcgY2xhc3NlcyBhcyBpbmplY3RhYmxlXG4gKiBhbmQgZm9yIGluamVjdGluZyBkZXBlbmRlbmNpZXMgaW50byBjbGFzcyBwcm9wZXJ0aWVzLlxuICpcbiAqIEBtb2R1bGUgaW5qZWN0YWJsZS1kZWNvcmF0b3JzXG4gKi9cblxuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9JbmplY3RhYmxlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVnaXN0cnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgaW5qZWN0YWJsZS1kZWNvcmF0b3JzIGxpYnJhcnkuXG4gKiBAc3VtbWFyeSBEZWZpbmVkIG9uIGxpYnJhcnkgYnVpbGQuIEhvbGRzIHRoZSBsaWJyYXJ5J3MgY3VycmVudCB2ZXJzaW9uIHN0cmluZy5cbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmluamVjdGFibGUtZGVjb3JhdG9yc1xuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==
+export const VERSION = "1.6.4";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFDN0IsaUNBQThCO0FBQzlCLDhCQUEyQjtBQUMzQiwyQkFBd0I7QUFDeEIsMkJBQXdCO0FBRXhCOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIEEgbGlnaHR3ZWlnaHQgZGVwZW5kZW5jeSBpbmplY3Rpb24gbGlicmFyeSBmb3IgVHlwZVNjcmlwdCBhcHBsaWNhdGlvbnMuXG4gKiBAc3VtbWFyeSBBZGRzIGEgc2ltcGxlIEluamVjdGFibGVzIGltcGxlbWVudGF0aW9uIHRvIGNyZWF0ZSBzaW5nbGV0b24gaW5zdGFuY2VzIG9mIGFuIG9iamVjdFxuICogYW5kIGVhc2lseSBpbmplY3QgaXQgaW50byBvdGhlciBvYmplY3RzLiBQcm92aWRlcyBkZWNvcmF0b3JzIGZvciBtYXJraW5nIGNsYXNzZXMgYXMgaW5qZWN0YWJsZVxuICogYW5kIGZvciBpbmplY3RpbmcgZGVwZW5kZW5jaWVzIGludG8gY2xhc3MgcHJvcGVydGllcy5cbiAqXG4gKiBAbW9kdWxlIGluamVjdGFibGUtZGVjb3JhdG9yc1xuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vSW5qZWN0YWJsZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3JlZ2lzdHJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ3VycmVudCB2ZXJzaW9uIG9mIHRoZSBpbmplY3RhYmxlLWRlY29yYXRvcnMgbGlicmFyeS5cbiAqIEBzdW1tYXJ5IERlZmluZWQgb24gbGlicmFyeSBidWlsZC4gSG9sZHMgdGhlIGxpYnJhcnkncyBjdXJyZW50IHZlcnNpb24gc3RyaW5nLlxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6aW5qZWN0YWJsZS1kZWNvcmF0b3JzXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19

package/lib/esm/registry.d.ts

@@ -1,3 +1,4 @@
+import { InjectableOptions } from "./types";
 /**
  * @description Type representing either a class constructor or an instance.
  * @summary Defines an Injectable type that can be either a class constructor or an instance of a class.
@@ -20,32 +21,35 @@ export interface InjectablesRegistry {
      * @description Fetches an injectable instance by its registered name.
      * @summary Retrieves an {@link Injectable} from the registry by name, optionally passing constructor arguments.
      * @template T Type of the injectable object to retrieve
-     * @param {string} name The registered name of the injectable to retrieve
+     * @param {symbol} name The registered name of the injectable to retrieve
      * @param {any[]} args Constructor arguments to pass when instantiating the injectable
      * @return {Injectable<T> | undefined} The injectable instance or undefined if not found
      * @memberOf module:injectable-decorators
      */
-    get<T>(name: string, ...args: any[]): Injectable<T> | undefined;
+    get<T>(name: symbol | string | {
+        new (...args: any[]): T;
+    }, ...args: any[]): T | undefined;
     /**
      * @description Adds a class or object to the injectable registry.
      * @summary Registers an injectable constructor or instance with the registry, making it available for injection.
      * @template T Type of the injectable object to register
      * @param {Injectable<T>} constructor The class constructor or object instance to register
+     * @param options
      * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)
      * @return {void}
      * @memberOf module:injectable-decorators
      */
-    register<T>(constructor: Injectable<T>, ...args: any[]): void;
+    register<T>(constructor: Injectable<T>, category: symbol | undefined, options: InjectableOptions<T>, ...args: any[]): void;
     /**
      * @description Creates a new instance of an injectable class.
      * @summary Instantiates an injectable class using its constructor and the provided arguments.
      * @template T Type of the object to build
-     * @param {Record<string, any>} obj Object containing the name of the injectable to build
+     * @param {symbol} name Object containing the name of the injectable to build
      * @param {any[]} args Constructor arguments to pass when instantiating the injectable
      * @return {T} The newly created instance
      * @memberOf module:injectable-decorators
      */
-    build<T>(obj: Record<string, any>, ...args: any[]): T;
+    build<T>(name: symbol, ...args: any[]): T;
 }
 /**
  * @description Default implementation of the InjectablesRegistry interface.
@@ -91,18 +95,21 @@ export interface InjectablesRegistry {
  */
 export declare class InjectableRegistryImp implements InjectablesRegistry {
     private cache;
+    has<T>(name: symbol | {
+        new (...args: any[]): T;
+    }): boolean;
     /**
      * @inheritDoc
      */
-    get<T>(name: string, ...args: any[]): T | undefined;
+    get<T>(name: symbol | string | {
+        new (...args: any[]): T;
+    }, ...args: any[]): T | undefined;
     /**
      * @inheritDoc
      */
-    register<T>(obj: Injectable<T>, category?: string | undefined, isSingleton?: boolean, force?: boolean): void;
+    register<T>(obj: Injectable<T>, category: symbol | undefined, options: InjectableOptions<T>, force?: boolean): void;
     /**
      * @inheritDoc
      */
-    build<T>(defs: {
-        name: string;
-    }, ...args: any[]): T;
+    build<T>(name: symbol, ...args: any[]): T;
 }

package/lib/esm/registry.js

@@ -1,3 +1,5 @@
+import { InjectablesKeys } from "./constants.js";
+import { getInjectKey } from "./decorators.js";
 /**
  * @description Default implementation of the InjectablesRegistry interface.
  * @summary Holds the various {@link Injectable}s in a cache and provides methods to register, retrieve, and build them.
@@ -44,53 +46,63 @@ export class InjectableRegistryImp {
     constructor() {
         this.cache = {};
     }
+    has(name) {
+        if (typeof name === "symbol")
+            return name in this.cache;
+        return Symbol.for(name.toString()) in this.cache;
+    }
     /**
      * @inheritDoc
      */
     get(name, ...args) {
-        try {
-            const innerCache = this.cache[name];
-            const buildDef = { name: name };
-            if (!innerCache.singleton && !innerCache.instance)
-                return this.build(buildDef, ...args);
-            return innerCache.instance || this.build(buildDef, ...args);
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        if (typeof name === "string")
+            name = Symbol.for(name);
+        if (typeof name !== "symbol") {
+            const meta = Reflect.getMetadata(getInjectKey(InjectablesKeys.INJECTABLE), name);
+            name = meta?.symbol || Symbol.for(name.toString());
         }
-        catch (e) {
+        if (!name)
+            throw new Error(`Injectable ${name} not found`);
+        if (!(name in this.cache)) {
             return undefined;
         }
+        const cache = this.cache[name];
+        if (!cache.options.singleton && !cache.instance)
+            return this.build(name, ...args);
+        return cache.instance || this.build(name, ...args);
     }
     /**
      * @inheritDoc
      */
-    register(obj, category = undefined, isSingleton = true, force = false) {
+    register(obj, category, options, force = false) {
         const castObj = obj;
         const constructor = !castObj.name && castObj.constructor;
         if (typeof castObj !== "function" && !constructor)
             throw new Error(`Injectable registering failed. Missing Class name or constructor`);
-        const name = category ||
-            (constructor && constructor.name && constructor.name !== "Function"
-                ? constructor.name
-                : castObj.name);
+        const name = category || Symbol.for(obj.toString());
         if (!this.cache[name] || force)
             this.cache[name] = {
                 instance: constructor ? obj : undefined,
-                constructor: !constructor ? obj : undefined,
-                singleton: isSingleton,
+                constructor: !constructor ? obj : obj.constructor,
+                options: options,
             };
     }
     /**
      * @inheritDoc
      */
-    build(defs, ...args) {
-        const { constructor, singleton } = this.cache[defs.name];
-        const instance = new constructor(...args);
-        this.cache[defs.name] = {
-            instance: instance,
-            constructor: constructor,
-            singleton: singleton,
-        };
+    build(name, ...args) {
+        const { constructor, options } = this.cache[name];
+        let instance;
+        try {
+            instance = new constructor(...args);
+        }
+        catch (e) {
+            throw new Error(`failed to build ${name.toString()} with args ${args}: ${e}`);
+        }
+        this.cache[name].instance = instance;
+        if (options.callback)
+            instance = options.callback(instance, ...args);
         return instance;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,OAAO,qBAAqB;IAAlC;QACU,UAAK,GAA+B,EAAE,CAAC;IA4DjD,CAAC;IA1DC;;OAEG;IACH,GAAG,CAAI,IAAY,EAAE,GAAG,IAAW;QACjC,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpC,MAAM,QAAQ,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;YAChC,IAAI,CAAC,UAAU,CAAC,SAAS,IAAI,CAAC,UAAU,CAAC,QAAQ;gBAC/C,OAAO,IAAI,CAAC,KAAK,CAAI,QAAQ,EAAE,GAAG,IAAI,CAAC,CAAC;YAC1C,OAAO,UAAU,CAAC,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAI,QAAQ,EAAE,GAAG,IAAI,CAAC,CAAC;YAC/D,6DAA6D;QAC/D,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IACD;;OAEG;IACH,QAAQ,CACN,GAAkB,EAClB,WAA+B,SAAS,EACxC,cAAuB,IAAI,EAC3B,QAAiB,KAAK;QAEtB,MAAM,OAAO,GAAwB,GAA0B,CAAC;QAEhE,MAAM,WAAW,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;QACzD,IAAI,OAAO,OAAO,KAAK,UAAU,IAAI,CAAC,WAAW;YAC/C,MAAM,IAAI,KAAK,CACb,kEAAkE,CACnE,CAAC;QAEJ,MAAM,IAAI,GACR,QAAQ;YACR,CAAC,WAAW,IAAI,WAAW,CAAC,IAAI,IAAI,WAAW,CAAC,IAAI,KAAK,UAAU;gBACjE,CAAC,CAAE,WAA0C,CAAC,IAAI;gBAClD,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEpB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK;YAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG;gBACjB,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS;gBACvC,WAAW,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS;gBAC3C,SAAS,EAAE,WAAW;aACvB,CAAC;IACN,CAAC;IACD;;OAEG;IACH,KAAK,CAAI,IAAsB,EAAE,GAAG,IAAW;QAC7C,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,WAAW,CAAC,GAAG,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;YACtB,QAAQ,EAAE,QAAQ;YAClB,WAAW,EAAE,WAAW;YACxB,SAAS,EAAE,SAAS;SACrB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF","sourcesContent":["/**\n * @description Type representing either a class constructor or an instance.\n * @summary Defines an Injectable type that can be either a class constructor or an instance of a class.\n * @template T The type of the injectable object\n * @typedef {function(any): T | T} Injectable\n * @memberOf module:injectable-decorators\n */\nexport type Injectable<T> = { new (...args: any[]): T } | T;\n\n/**\n * @description Contract for a registry that manages injectable objects.\n * @summary Interface for an injectable registry that provides methods for retrieving, registering, and building injectable objects.\n * @template T Type parameter used in the interface methods\n * @interface InjectablesRegistry\n * @memberOf module:injectable-decorators\n */\nexport interface InjectablesRegistry {\n  /**\n   * @description Fetches an injectable instance by its registered name.\n   * @summary Retrieves an {@link Injectable} from the registry by name, optionally passing constructor arguments.\n   * @template T Type of the injectable object to retrieve\n   * @param {string} name The registered name of the injectable to retrieve\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {Injectable<T> | undefined} The injectable instance or undefined if not found\n   * @memberOf module:injectable-decorators\n   */\n  get<T>(name: string, ...args: any[]): Injectable<T> | undefined;\n\n  /**\n   * @description Adds a class or object to the injectable registry.\n   * @summary Registers an injectable constructor or instance with the registry, making it available for injection.\n   * @template T Type of the injectable object to register\n   * @param {Injectable<T>} constructor The class constructor or object instance to register\n   * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)\n   * @return {void}\n   * @memberOf module:injectable-decorators\n   */\n  register<T>(constructor: Injectable<T>, ...args: any[]): void;\n\n  /**\n   * @description Creates a new instance of an injectable class.\n   * @summary Instantiates an injectable class using its constructor and the provided arguments.\n   * @template T Type of the object to build\n   * @param {Record<string, any>} obj Object containing the name of the injectable to build\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {T} The newly created instance\n   * @memberOf module:injectable-decorators\n   */\n  build<T>(obj: Record<string, any>, ...args: any[]): T;\n}\n\n/**\n * @description Default implementation of the InjectablesRegistry interface.\n * @summary Holds the various {@link Injectable}s in a cache and provides methods to register, retrieve, and build them.\n * @template T Type parameter used in the class methods\n *\n * @class InjectableRegistryImp\n * @implements InjectablesRegistry\n *\n * @memberOf module:injectable-decorators\n *\n * @example\n * // Create a new registry\n * const registry = new InjectableRegistryImp();\n *\n * // Register a class\n * class MyService {\n *   doSomething() {\n *     return 'Hello World';\n *   }\n * }\n * registry.register(MyService, 'MyService', true);\n *\n * // Get the instance\n * const service = registry.get('MyService');\n * service.doSomething(); // 'Hello World'\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Registry\n *\n *   Client->>Registry: register(MyService)\n *   Registry->>Registry: Store in cache\n *\n *   Client->>Registry: get(\"MyService\")\n *   alt Instance exists and is singleton\n *     Registry-->>Client: Return cached instance\n *   else No instance or not singleton\n *     Registry->>Registry: build(name)\n *     Registry-->>Client: Return new instance\n *   end\n */\nexport class InjectableRegistryImp implements InjectablesRegistry {\n  private cache: { [indexer: string]: any } = {};\n\n  /**\n   * @inheritDoc\n   */\n  get<T>(name: string, ...args: any[]): T | undefined {\n    try {\n      const innerCache = this.cache[name];\n      const buildDef = { name: name };\n      if (!innerCache.singleton && !innerCache.instance)\n        return this.build<T>(buildDef, ...args);\n      return innerCache.instance || this.build<T>(buildDef, ...args);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e) {\n      return undefined;\n    }\n  }\n  /**\n   * @inheritDoc\n   */\n  register<T>(\n    obj: Injectable<T>,\n    category: string | undefined = undefined,\n    isSingleton: boolean = true,\n    force: boolean = false\n  ): void {\n    const castObj: Record<string, any> = obj as Record<string, any>;\n\n    const constructor = !castObj.name && castObj.constructor;\n    if (typeof castObj !== \"function\" && !constructor)\n      throw new Error(\n        `Injectable registering failed. Missing Class name or constructor`\n      );\n\n    const name =\n      category ||\n      (constructor && constructor.name && constructor.name !== \"Function\"\n        ? (constructor as { [indexer: string]: any }).name\n        : castObj.name);\n\n    if (!this.cache[name] || force)\n      this.cache[name] = {\n        instance: constructor ? obj : undefined,\n        constructor: !constructor ? obj : undefined,\n        singleton: isSingleton,\n      };\n  }\n  /**\n   * @inheritDoc\n   */\n  build<T>(defs: { name: string }, ...args: any[]): T {\n    const { constructor, singleton } = this.cache[defs.name];\n    const instance = new constructor(...args);\n    this.cache[defs.name] = {\n      instance: instance,\n      constructor: constructor,\n      singleton: singleton,\n    };\n    return instance;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"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","sourcesContent":["import { InjectableDef, InjectableOptions } from \"./types\";\nimport { InjectablesKeys } from \"./constants\";\nimport { getInjectKey } from \"./decorators\";\n\n/**\n * @description Type representing either a class constructor or an instance.\n * @summary Defines an Injectable type that can be either a class constructor or an instance of a class.\n * @template T The type of the injectable object\n * @typedef {function(any): T | T} Injectable\n * @memberOf module:injectable-decorators\n */\nexport type Injectable<T> = { new (...args: any[]): T } | T;\n\n/**\n * @description Contract for a registry that manages injectable objects.\n * @summary Interface for an injectable registry that provides methods for retrieving, registering, and building injectable objects.\n * @template T Type parameter used in the interface methods\n * @interface InjectablesRegistry\n * @memberOf module:injectable-decorators\n */\nexport interface InjectablesRegistry {\n  /**\n   * @description Fetches an injectable instance by its registered name.\n   * @summary Retrieves an {@link Injectable} from the registry by name, optionally passing constructor arguments.\n   * @template T Type of the injectable object to retrieve\n   * @param {symbol} name The registered name of the injectable to retrieve\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {Injectable<T> | undefined} The injectable instance or undefined if not found\n   * @memberOf module:injectable-decorators\n   */\n  get<T>(\n    name: symbol | string | { new (...args: any[]): T },\n    ...args: any[]\n  ): T | undefined;\n\n  /**\n   * @description Adds a class or object to the injectable registry.\n   * @summary Registers an injectable constructor or instance with the registry, making it available for injection.\n   * @template T Type of the injectable object to register\n   * @param {Injectable<T>} constructor The class constructor or object instance to register\n   * @param options\n   * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)\n   * @return {void}\n   * @memberOf module:injectable-decorators\n   */\n  register<T>(\n    constructor: Injectable<T>,\n    category: symbol | undefined,\n    options: InjectableOptions<T>,\n    ...args: any[]\n  ): void;\n\n  /**\n   * @description Creates a new instance of an injectable class.\n   * @summary Instantiates an injectable class using its constructor and the provided arguments.\n   * @template T Type of the object to build\n   * @param {symbol} name Object containing the name of the injectable to build\n   * @param {any[]} args Constructor arguments to pass when instantiating the injectable\n   * @return {T} The newly created instance\n   * @memberOf module:injectable-decorators\n   */\n  build<T>(name: symbol, ...args: any[]): T;\n}\n\n/**\n * @description Default implementation of the InjectablesRegistry interface.\n * @summary Holds the various {@link Injectable}s in a cache and provides methods to register, retrieve, and build them.\n * @template T Type parameter used in the class methods\n *\n * @class InjectableRegistryImp\n * @implements InjectablesRegistry\n *\n * @memberOf module:injectable-decorators\n *\n * @example\n * // Create a new registry\n * const registry = new InjectableRegistryImp();\n *\n * // Register a class\n * class MyService {\n *   doSomething() {\n *     return 'Hello World';\n *   }\n * }\n * registry.register(MyService, 'MyService', true);\n *\n * // Get the instance\n * const service = registry.get('MyService');\n * service.doSomething(); // 'Hello World'\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Registry\n *\n *   Client->>Registry: register(MyService)\n *   Registry->>Registry: Store in cache\n *\n *   Client->>Registry: get(\"MyService\")\n *   alt Instance exists and is singleton\n *     Registry-->>Client: Return cached instance\n *   else No instance or not singleton\n *     Registry->>Registry: build(name)\n *     Registry-->>Client: Return new instance\n *   end\n */\nexport class InjectableRegistryImp implements InjectablesRegistry {\n  private cache: Record<symbol, InjectableDef> = {};\n\n  has<T>(name: symbol | { new (...args: any[]): T }): boolean {\n    if (typeof name === \"symbol\") return name in this.cache;\n    return Symbol.for(name.toString()) in this.cache;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  get<T>(\n    name: symbol | string | { new (...args: any[]): T },\n    ...args: any[]\n  ): T | undefined {\n    if (typeof name === \"string\") name = Symbol.for(name);\n    if (typeof name !== \"symbol\") {\n      const meta = Reflect.getMetadata(\n        getInjectKey(InjectablesKeys.INJECTABLE),\n        name\n      );\n      name = (meta?.symbol as symbol) || Symbol.for(name.toString());\n    }\n    if (!name) throw new Error(`Injectable ${name} not found`);\n\n    if (!((name as symbol) in this.cache)) {\n      return undefined;\n    }\n    const cache = this.cache[name];\n    if (!cache.options.singleton && !cache.instance)\n      return this.build<T>(name, ...args);\n    return cache.instance || this.build<T>(name, ...args);\n  }\n  /**\n   * @inheritDoc\n   */\n  register<T>(\n    obj: Injectable<T>,\n    category: symbol | undefined,\n    options: InjectableOptions<T>,\n    force: boolean = false\n  ): void {\n    const castObj: Record<string, any> = obj as Record<string, any>;\n\n    const constructor = !castObj.name && castObj.constructor;\n    if (typeof castObj !== \"function\" && !constructor)\n      throw new Error(\n        `Injectable registering failed. Missing Class name or constructor`\n      );\n\n    const name = category || Symbol.for((obj as any).toString());\n\n    if (!this.cache[name] || force)\n      this.cache[name] = {\n        instance: constructor ? obj : undefined,\n        constructor: !constructor ? obj : (obj as any).constructor,\n        options: options,\n      };\n  }\n  /**\n   * @inheritDoc\n   */\n  build<T>(name: symbol, ...args: any[]): T {\n    const { constructor, options } = this.cache[name];\n    let instance: T;\n    try {\n      instance = new constructor(...args);\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to build ${name.toString()} with args ${args}: ${e}`\n      );\n    }\n    this.cache[name].instance = instance;\n    if (options.callback) instance = options.callback(instance, ...args);\n    return instance;\n  }\n}\n"]}

package/lib/esm/types.d.ts

@@ -0,0 +1,16 @@
+export type InstanceCallback<T> = (instance: T, ...args: any[]) => T;
+export type InjectableOptions<T> = {
+    singleton: boolean;
+    callback: InstanceCallback<T>;
+};
+export type InjectableDef<T = any, OPTS extends InjectableOptions<T> = InjectableOptions<T>> = {
+    options: OPTS;
+    instance?: any;
+    constructor: {
+        new (...args: any[]): any;
+    };
+};
+export type InjectableMetadata = {
+    class: string;
+    symbol: symbol;
+};

package/lib/esm/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEluc3RhbmNlQ2FsbGJhY2s8VD4gPSAoaW5zdGFuY2U6IFQsIC4uLmFyZ3M6IGFueVtdKSA9PiBUO1xuXG5leHBvcnQgdHlwZSBJbmplY3RhYmxlT3B0aW9uczxUPiA9IHtcbiAgc2luZ2xldG9uOiBib29sZWFuO1xuICBjYWxsYmFjazogSW5zdGFuY2VDYWxsYmFjazxUPjtcbn07XG5cbmV4cG9ydCB0eXBlIEluamVjdGFibGVEZWY8XG4gIFQgPSBhbnksXG4gIE9QVFMgZXh0ZW5kcyBJbmplY3RhYmxlT3B0aW9uczxUPiA9IEluamVjdGFibGVPcHRpb25zPFQ+LFxuPiA9IHtcbiAgb3B0aW9uczogT1BUUztcbiAgaW5zdGFuY2U/OiBhbnk7XG4gIGNvbnN0cnVjdG9yOiB7IG5ldyAoLi4uYXJnczogYW55W10pOiBhbnkgfTtcbn07XG5cbmV4cG9ydCB0eXBlIEluamVjdGFibGVNZXRhZGF0YSA9IHtcbiAgY2xhc3M6IHN0cmluZztcbiAgc3ltYm9sOiBzeW1ib2w7XG59O1xuIl19

package/lib/esm/utils.d.ts

@@ -15,4 +15,4 @@ export declare const TypeKey = "design:type";
  * @function getTypeFromDecorator
  * @memberOf module:injectable-decorators
  */
-export declare function getTypeFromDecorator(model: any, propKey: string | symbol): string | undefined;
+export declare function getTypeFromDecorator(model: any, propKey: string | symbol): symbol | undefined;

package/lib/esm/utils.js

@@ -1,4 +1,6 @@
 import "reflect-metadata";
+import { getInjectKey } from "./decorators.js";
+import { InjectablesKeys } from "./constants.js";
 /**
  * @description Reflection metadata key for accessing TypeScript type information.
  * @summary Holds the key for retrieving the design type from TypeScript's reflection metadata.
@@ -17,6 +19,13 @@ export const TypeKey = "design:type";
  */
 export function getTypeFromDecorator(model, propKey) {
     const typeDef = Reflect.getMetadata(TypeKey, model, propKey);
-    return typeDef.name !== "Function" ? typeDef.name : undefined;
+    if (typeDef.name === "Function") {
+        return undefined;
+    }
+    const meta = Reflect.getMetadata(getInjectKey(InjectablesKeys.INJECTABLE), typeDef);
+    if (!meta) {
+        return undefined;
+    }
+    return meta.symbol;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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