@decaf-ts/injectable-decorators 1.6.7 → 1.6.9

package/lib/esm/decorators.d.ts

@@ -1,60 +1,101 @@
 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
+ * @description Configuration options for the @injectable decorator.
+ * @summary Controls lifecycle (singleton vs on-demand) and an optional instance transformation callback executed post-construction.
+ * @template T The instance type affected by the callback when provided.
+ * @property {boolean} singleton When true, a single instance is shared (singleton). When false, instances are created on demand.
+ * @property {InstanceCallback<T>} [callback] Optional hook to transform the instance after it is constructed.
+ * @typedef InjectableConfig
  * @memberOf module:injectable-decorators
  */
-export declare const getInjectKey: (key: string) => string;
+export type InjectableConfig = {
+    singleton: boolean;
+    callback?: InstanceCallback<any>;
+};
+/**
+ * @description Generic constructor type for class-like values.
+ * @summary Represents any class that can be instantiated with arbitrary arguments, producing an instance of type T.
+ * @template T The instance type created by the constructor.
+ * @typedef Constructor
+ * @example
+ * // Using Constructor to type a factory
+ * function make<T>(Ctor: Constructor<T>, ...args: any[]): T {
+ *   return new Ctor(...args);
+ * }
+ * @memberOf module:injectable-decorators
+ */
+export type Constructor<T = any> = {
+    new (...args: any[]): T;
+};
 /**
  * @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.
- * When applied to a class, replaces its constructor with one that returns a singleton instance.
+ * @summary Defines a class as an injectable that can be retrieved from the registry.
+ * When applied to a class, replaces its constructor with one that returns an instance.
+ *
+ * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
- * @param {string} [category] Defaults to the class name. Useful when minification occurs and names are changed,
+ * @function injectable
+ */
+export declare function injectable(): (original: any) => any;
+/**
+ * @description Decorator that marks a class as available for dependency injection.
+ * @summary Defines a class as an injectable that can be retrieved from the registry.
+ * When applied to a class, replaces its constructor with one that returns an instance.
+ *
+ * @param {string | Constructor} category Defaults to the class category. Useful when minification occurs and names are changed,
  * or when you want to upcast the object to a different type.
- * @param {boolean} [force] Defines if the injectable should override an already existing instance (if any).
- * Only meant for extending decorators.
- * @param {Function} [instanceCallback] Optional callback function that will be called with the instance after creation.
- * @return {Function} A decorator function that transforms the class into an injectable.
+ *
+ * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Class Decorators
+ */
+export declare function injectable(category: string | Constructor): (original: any) => any;
+/**
+ * @description Decorator that marks a class as available for dependency injection.
+ * @summary Defines a class as an injectable that can be retrieved from the registry.
+ * When applied to a class, replaces its constructor with one that returns an instance.
  *
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant Decorator
- *   participant Injectables
- *
- *   Client->>Decorator: @injectable()
- *   Decorator->>Decorator: Create new constructor
- *
- *   Note over Decorator: When new instance requested
- *   Decorator->>Injectables: get(name)
- *   alt Instance exists
- *     Injectables-->>Decorator: Return existing instance
- *   else No instance
- *     Decorator->>Injectables: register(original, name)
- *     Decorator->>Injectables: get(name)
- *     Injectables-->>Decorator: Return new instance
- *     opt Has callback
- *       Decorator->>Decorator: Call instanceCallback
- *     end
- *   end
- *   Decorator->>Decorator: Define metadata
- *   Decorator-->>Client: Return instance
+ * @param {Partial<InjectableConfig>} cfg=DefaultInjectableConfig Allows overriding the default singleton behavior and adding a callback function.
+ *
+ * @return {function(any): any} A decorator function that transforms the class into an injectable.
+ *
+ * @function injectable
  */
-export declare function injectable(): (original: any) => any;
-export declare function injectable(category: string | {
-    new (...args: any[]): any;
-}): (original: any) => any;
-export declare function injectable(instanceCallback: InstanceCallback<any>): (original: any) => any;
-export declare function injectable(category: string | {
-    new (...args: any[]): any;
-}, instanceCallback: InstanceCallback<any>): (original: any) => any;
+export declare function injectable(cfg: Partial<InjectableConfig>): (original: any) => any;
+/**
+ * @description Decorator that marks a class as available for dependency injection.
+ * @summary Defines a class as an injectable that can be retrieved from the registry.
+ * When applied to a class, replaces its constructor with one that returns an instance.
+ *
+ * @param category Defaults to the class category. Useful when minification occurs and names are changed,
+ * or when you want to upcast the object to a different type.
+ * @param {Partial<InjectableConfig>} cfg=DefaultInjectableConfig Allows overriding the default singleton behavior and adding a callback function.
+ *
+ * @return {function(any): any} A decorator function that transforms the class into an injectable.
+ *
+ * @function injectable
+ */
+export declare function injectable(category: string | Constructor, cfg: Partial<InjectableConfig>): (original: any) => any;
+/**
+ * @description Convenience decorator to register an injectable as a singleton.
+ * @summary Wraps {@link injectable} forcing the singleton lifecycle so only one instance is created and reused.
+ * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.
+ * @param {Omit<InjectableConfig, "singleton">} [cfg] Additional injectable configuration excluding the singleton flag.
+ * @return {function(any): any} A class decorator that registers the target as a singleton injectable.
+ * @function singleton
+ * @category Class Decorators
+ */
+export declare function singleton(category?: string | Constructor, cfg?: Omit<InjectableConfig, "singleton">): (original: any) => any;
+/**
+ * @description Convenience decorator to register an injectable as on-demand (non-singleton).
+ * @summary Wraps {@link injectable} forcing new instances to be created on every injection or retrieval.
+ * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.
+ * @param {Omit<InjectableConfig, "singleton">} [cfg] Additional injectable configuration excluding the singleton flag.
+ * @return {function(any): any} A class decorator that registers the target as a non-singleton injectable.
+ * @function onDemand
+ * @category Class Decorators
+ */
+export declare function onDemand(category?: string | Constructor, cfg?: Omit<InjectableConfig, "singleton">): (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.
@@ -64,68 +105,65 @@ export declare function injectable(category: string | {
  * @return {any} The transformed injectable instance
  *
  * @typedef {Function} InstanceTransformer
+ * @category Decorators
  * @memberOf module:injectable-decorators
  */
 export type InstanceTransformer = (injectable: any, obj: any) => any;
+/**
+ * @description Options for the property-level @inject decorator.
+ * @summary Allows specifying constructor arguments and an optional transformer to be applied to the resolved instance.
+ * @property {any[]} [args] Optional constructor arguments to use when building the injectable instance.
+ * @property {InstanceTransformer} [transformer] Optional function to transform the instance before assignment.
+ * @typedef InjectOptions
+ * @memberOf module:injectable-decorators
+ */
+export type InjectOptions = {
+    args?: any[];
+    transformer?: InstanceTransformer;
+};
+/**
+ * @description Property decorator that injects a dependency into a class property.
+ * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
+ * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
+ *
+ * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
+ *
+ * @function inject
+ */
+export declare function inject(): (target: any, propertyKey: any) => void;
 /**
  * @description Property decorator that injects a dependency into a class property.
  * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
  * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
  *
- * Injected properties should be described like so:
- * <pre>
- *     class ClassName {
- *         ...
+ * @param {string} category Defaults to the class name derived from the property type. Useful when minification occurs
+ * and names are changed, or when you want to upcast the object to a different type.
+ * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
- *         @inject()
- *         propertyName!: InjectableClass;
+ * @function inject
+ */
+export declare function inject(category: string | Constructor): (target: any, propertyKey: any) => void;
+/**
+ * @description Property decorator that injects a dependency into a class property.
+ * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
+ * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
  *
- *         ...
- *     }
- * </pre>
+ * @param {Partial<InjectOptions>} [cfg={}] Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand
+ * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
- * where InjectableClass is the class you want to inject.
- * Notice the use of '!:' to ensure the transpiler the property will be set outside the constructor but will always be defined.
- * For projects where minification occurs, you should use the category param to ensure the name is the same throughout.
+ * @function inject
+ */
+export declare function inject(cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;
+/**
+ * @description Property decorator that injects a dependency into a class property.
+ * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
+ * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
  *
- * @param {string} [category] Defaults to the class name derived from the property type. Useful when minification occurs
+ * @param {string} category Defaults to the class name derived from the property type. Useful when minification occurs
  * and names are changed, or when you want to upcast the object to a different type.
- * @param {InstanceTransformer} [transformer] Optional function to transform the injectable instance before it's injected.
- * @return {Function} A property decorator function that sets up the dependency injection.
+ * @param {Partial<InjectOptions>} cfg={} Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand
+ * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Property Decorators
- *
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant Decorator
- *   participant Injectables
- *
- *   Client->>Decorator: @inject()
- *   Decorator->>Decorator: Get type from property
- *   Decorator->>Decorator: Define metadata
- *   Decorator->>Decorator: Define property getter
- *
- *   Note over Decorator: When property accessed
- *   Client->>Decorator: access property
- *   Decorator->>Decorator: Check if instance exists
- *   alt Instance exists in WeakMap
- *     Decorator-->>Client: Return cached instance
- *   else No instance
- *     Decorator->>Injectables: get(name)
- *     alt Injectable found
- *       Injectables-->>Decorator: Return injectable instance
- *       opt Has transformer
- *         Decorator->>Decorator: Call transformer
- *       end
- *       Decorator->>Decorator: Store in WeakMap
- *       Decorator-->>Client: Return instance
- *     else No injectable
- *       Decorator-->>Client: Throw error
- *     end
- *   end
  */
-export declare function inject(category?: symbol | string | {
-    new (...args: any[]): any;
-}, transformer?: InstanceTransformer, ...args: any[]): (target: any, propertyKey?: any) => void;
+export declare function inject(category: string | Constructor, cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;

package/lib/esm/decorators.js

@@ -1,29 +1,63 @@
-import { InjectablesKeys } from "./constants.js";
+import { DefaultInjectablesConfig, InjectablesKeys } from "./constants.js";
 import { Injectables } from "./Injectables.js";
-import { getTypeFromDecorator } from "./utils.js";
+import { getInjectKey, getTypeFromDecorator } from "./utils.js";
 /**
- * @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
+ * @description Decorator that marks a class as available for dependency injection.
+ * @summary Defines a class as an injectable that can be retrieved from the registry.
+ * When applied to a class, replaces its constructor with one that returns an instance.
+ *
+ * @param {string | Constructor} [category] Defaults to the class category. Useful when minification occurs and names are changed,
+ * or when you want to upcast the object to a different type.
+ * @param {Partial<InjectableConfig>} [cfg=DefaultInjectableConfig] Allows overriding the default singleton behavior and adding a callback function.
+ *
+ * @return {function(any): any} A decorator function that transforms the class into an injectable.
+ *
+ * @function injectable
+ * @category Class Decorators
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Decorator
+ *   participant Injectables
+ *
+ *   Client->>Decorator: @injectable()
+ *   Decorator->>Decorator: Create new constructor
+ *
+ *   Note over Decorator: When new instance requested
+ *   Decorator->>Injectables: get(category)
+ *   alt Instance exists
+ *     Injectables-->>Decorator: Return existing instance
+ *   else No instance
+ *     Decorator->>Injectables: register(original, category)
+ *     Decorator->>Injectables: get(category)
+ *     Injectables-->>Decorator: Return new instance
+ *     opt Has callback
+ *       Decorator->>Decorator: Call instanceCallback
+ *     end
+ *   end
+ *   Decorator->>Decorator: Define metadata
+ *   Decorator-->>Client: Return instance
  */
-export const getInjectKey = (key) => InjectablesKeys.REFLECT + key;
-export function injectable(name, cb) {
-    const instanceCallback = (typeof name === "function" && !name.name ? name : cb);
-    const category = typeof name === "string"
-        ? name
-        : cb
-            ? name
-            : typeof name === "function" && !name.name
-                ? undefined
-                : name;
+export function injectable(category, cfg) {
+    cfg =
+        cfg ||
+            (typeof category === "object"
+                ? Object.assign(category, DefaultInjectablesConfig)
+                : DefaultInjectablesConfig);
+    category =
+        typeof category === "object"
+            ? undefined
+            : typeof category === "string"
+                ? category
+                : typeof category === "function" && category.name
+                    ? category
+                    : undefined;
     return (original) => {
         const symbol = Symbol.for(category || original.toString());
-        const name = category || original.name;
+        category = category || original.name;
         const metadata = {
-            class: name,
+            class: category,
             symbol: symbol,
         };
         Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECTABLE), metadata, original);
@@ -41,16 +75,36 @@ export function injectable(name, cb) {
             configurable: false,
             value: original.prototype.constructor.name,
         });
-        const opts = {
-            singleton: true,
-            callback: instanceCallback,
-        };
         Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECTABLE), metadata, newConstructor);
-        Injectables.register(original, symbol, opts);
+        Injectables.register(original, symbol, cfg);
         // return new constructor (will override original)
         return newConstructor;
     };
 }
+/**
+ * @description Convenience decorator to register an injectable as a singleton.
+ * @summary Wraps {@link injectable} forcing the singleton lifecycle so only one instance is created and reused.
+ * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.
+ * @param {Omit<InjectableConfig, "singleton">} [cfg] Additional injectable configuration excluding the singleton flag.
+ * @return {function(any): any} A class decorator that registers the target as a singleton injectable.
+ * @function singleton
+ * @category Class Decorators
+ */
+export function singleton(category, cfg) {
+    return injectable(category, Object.assign({}, cfg || {}, { singleton: true }));
+}
+/**
+ * @description Convenience decorator to register an injectable as on-demand (non-singleton).
+ * @summary Wraps {@link injectable} forcing new instances to be created on every injection or retrieval.
+ * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.
+ * @param {Omit<InjectableConfig, "singleton">} [cfg] Additional injectable configuration excluding the singleton flag.
+ * @return {function(any): any} A class decorator that registers the target as a non-singleton injectable.
+ * @function onDemand
+ * @category Class Decorators
+ */
+export function onDemand(category, cfg) {
+    return injectable(category, Object.assign({}, cfg || {}, { singleton: false }));
+}
 /**
  * @description Property decorator that injects a dependency into a class property.
  * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
@@ -74,8 +128,8 @@ export function injectable(name, cb) {
  *
  * @param {string} [category] Defaults to the class name derived from the property type. Useful when minification occurs
  * and names are changed, or when you want to upcast the object to a different type.
- * @param {InstanceTransformer} [transformer] Optional function to transform the injectable instance before it's injected.
- * @return {Function} A property decorator function that sets up the dependency injection.
+ * @param {Partial<InjectOptions>} [cfg={}] Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand
+ * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
  * @category Property Decorators
@@ -110,39 +164,43 @@ export function injectable(name, cb) {
  *     end
  *   end
  */
-export function inject(category, transformer, ...args) {
+export function inject(category, cfg) {
     return (target, propertyKey) => {
-        const values = new WeakMap();
-        const name = category || getTypeFromDecorator(target, propertyKey);
+        const config = (cfg || typeof category === "object" ? category : {});
+        const name = (typeof category !== "object" &&
+            category) ||
+            getTypeFromDecorator(target, propertyKey);
         if (!name) {
             throw new Error(`Could not get Type from decorator`);
         }
         Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECT), {
             injectable: name,
         }, target, propertyKey);
+        const values = new WeakMap();
         Object.defineProperty(target, propertyKey, {
             configurable: true,
             get() {
                 const descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
                 if (descriptor.configurable) {
+                    // let /obj: any;
                     Object.defineProperty(this, propertyKey, {
                         enumerable: true,
                         configurable: false,
                         get() {
                             let obj = values.get(this);
-                            if (!obj) {
-                                obj = Injectables.get(name, ...args);
-                                if (!obj)
-                                    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);
-                                    }
-                                    catch (e) {
-                                        console.error(e);
-                                    }
-                                values.set(this, obj);
-                            }
+                            if (obj)
+                                return obj;
+                            obj = Injectables.get(name, ...(config.args || []));
+                            if (!obj)
+                                throw new Error(`Could not get Injectable ${name.toString()} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`);
+                            if (config.transformer)
+                                try {
+                                    obj = config.transformer(obj, target);
+                                }
+                                catch (e) {
+                                    console.error(e);
+                                }
+                            values.set(this, obj);
                             return obj;
                         },
                     });
@@ -152,4 +210,4 @@ export function inject(category, transformer, ...args) {
         });
     };
 }
-//# 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\";\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(): (original: any) => any;\nexport function injectable(\n  category: string | { new (...args: any[]): any }\n): (original: any) => any;\nexport function injectable(\n  instanceCallback: InstanceCallback<any>\n): (original: any) => any;\nexport function injectable(\n  category: string | { new (...args: any[]): any },\n  instanceCallback: InstanceCallback<any>\n): (original: any) => any;\nexport function injectable(\n  name?: string | { new (...args: any[]): any } | InstanceCallback<any>,\n  cb?: InstanceCallback<any>\n) {\n  const instanceCallback = (\n    typeof name === \"function\" && !name.name ? name : cb\n  ) as InstanceCallback<any> | undefined;\n  const category =\n    typeof name === \"string\"\n      ? name\n      : cb\n        ? name\n        : typeof name === \"function\" && !name.name\n          ? undefined\n          : name;\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  ...args: any[]\n) {\n  return (target: any, propertyKey?: any) => {\n    const values = new WeakMap();\n\n    const name: symbol | string | { new (...args: any[]): any } | undefined =\n      category || 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, ...args);\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { DefaultInjectablesConfig, InjectablesKeys } from \"./constants\";\nimport { Injectables } from \"./Injectables\";\nimport { getInjectKey, getTypeFromDecorator } from \"./utils\";\nimport { InjectableMetadata, InstanceCallback } from \"./types\";\n\n/**\n * @description Configuration options for the @injectable decorator.\n * @summary Controls lifecycle (singleton vs on-demand) and an optional instance transformation callback executed post-construction.\n * @template T The instance type affected by the callback when provided.\n * @property {boolean} singleton When true, a single instance is shared (singleton). When false, instances are created on demand.\n * @property {InstanceCallback<T>} [callback] Optional hook to transform the instance after it is constructed.\n * @typedef InjectableConfig\n * @memberOf module:injectable-decorators\n */\nexport type InjectableConfig = {\n  singleton: boolean;\n  callback?: InstanceCallback<any>;\n};\n\n/**\n * @description Generic constructor type for class-like values.\n * @summary Represents any class that can be instantiated with arbitrary arguments, producing an instance of type T.\n * @template T The instance type created by the constructor.\n * @typedef Constructor\n * @example\n * // Using Constructor to type a factory\n * function make<T>(Ctor: Constructor<T>, ...args: any[]): T {\n *   return new Ctor(...args);\n * }\n * @memberOf module:injectable-decorators\n */\nexport type Constructor<T = any> = { new (...args: any[]): T };\n\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns an instance.\n *\n * @return {function(any): any} A decorator function that transforms the class into an injectable.\n *\n * @function injectable\n */\nexport function injectable(): (original: any) => any;\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns an instance.\n *\n * @param {string | Constructor} category Defaults to the class category. Useful when minification occurs and names are changed,\n * or when you want to upcast the object to a different type.\n *\n * @return {function(any): any} A decorator function that transforms the class into an injectable.\n *\n * @function injectable\n */\nexport function injectable(\n  category: string | Constructor\n): (original: any) => any;\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns an instance.\n *\n * @param {Partial<InjectableConfig>} cfg=DefaultInjectableConfig Allows overriding the default singleton behavior and adding a callback function.\n *\n * @return {function(any): any} A decorator function that transforms the class into an injectable.\n *\n * @function injectable\n */\nexport function injectable(\n  cfg: Partial<InjectableConfig>\n): (original: any) => any;\n\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns an instance.\n *\n * @param category Defaults to the class category. Useful when minification occurs and names are changed,\n * or when you want to upcast the object to a different type.\n * @param {Partial<InjectableConfig>} cfg=DefaultInjectableConfig Allows overriding the default singleton behavior and adding a callback function.\n *\n * @return {function(any): any} A decorator function that transforms the class into an injectable.\n *\n * @function injectable\n */\nexport function injectable(\n  category: string | Constructor,\n  cfg: Partial<InjectableConfig>\n): (original: any) => any;\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns an instance.\n *\n * @param {string | Constructor} [category] Defaults to the class category. Useful when minification occurs and names are changed,\n * or when you want to upcast the object to a different type.\n * @param {Partial<InjectableConfig>} [cfg=DefaultInjectableConfig] Allows overriding the default singleton behavior and adding a callback function.\n *\n * @return {function(any): any} 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(category)\n *   alt Instance exists\n *     Injectables-->>Decorator: Return existing instance\n *   else No instance\n *     Decorator->>Injectables: register(original, category)\n *     Decorator->>Injectables: get(category)\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 | Constructor | Partial<InjectableConfig>,\n  cfg?: Partial<InjectableConfig>\n) {\n  cfg =\n    cfg ||\n    (typeof category === \"object\"\n      ? Object.assign(category as Record<any, any>, DefaultInjectablesConfig)\n      : DefaultInjectablesConfig);\n  category =\n    typeof category === \"object\"\n      ? undefined\n      : typeof category === \"string\"\n        ? category\n        : typeof category === \"function\" && category.name\n          ? category\n          : undefined;\n\n  return (original: any) => {\n    const symbol = Symbol.for(category || original.toString());\n    category = category || original.name;\n\n    const metadata: InjectableMetadata = {\n      class: category as string,\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    Reflect.defineMetadata(\n      getInjectKey(InjectablesKeys.INJECTABLE),\n      metadata,\n      newConstructor\n    );\n\n    Injectables.register(original, symbol, cfg);\n    // return new constructor (will override original)\n    return newConstructor;\n  };\n}\n\n/**\n * @description Convenience decorator to register an injectable as a singleton.\n * @summary Wraps {@link injectable} forcing the singleton lifecycle so only one instance is created and reused.\n * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.\n * @param {Omit<InjectableConfig, \"singleton\">} [cfg] Additional injectable configuration excluding the singleton flag.\n * @return {function(any): any} A class decorator that registers the target as a singleton injectable.\n * @function singleton\n * @category Class Decorators\n */\nexport function singleton(\n  category?: string | Constructor,\n  cfg?: Omit<InjectableConfig, \"singleton\">\n) {\n  return injectable(\n    category as any,\n    Object.assign({}, cfg || {}, { singleton: true })\n  );\n}\n\n/**\n * @description Convenience decorator to register an injectable as on-demand (non-singleton).\n * @summary Wraps {@link injectable} forcing new instances to be created on every injection or retrieval.\n * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.\n * @param {Omit<InjectableConfig, \"singleton\">} [cfg] Additional injectable configuration excluding the singleton flag.\n * @return {function(any): any} A class decorator that registers the target as a non-singleton injectable.\n * @function onDemand\n * @category Class Decorators\n */\nexport function onDemand(\n  category?: string | Constructor,\n  cfg?: Omit<InjectableConfig, \"singleton\">\n) {\n  return injectable(\n    category as any,\n    Object.assign({}, cfg || {}, { singleton: false })\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 * @category Decorators\n * @memberOf module:injectable-decorators\n */\nexport type InstanceTransformer = (injectable: any, obj: any) => any;\n\n/**\n * @description Options for the property-level @inject decorator.\n * @summary Allows specifying constructor arguments and an optional transformer to be applied to the resolved instance.\n * @property {any[]} [args] Optional constructor arguments to use when building the injectable instance.\n * @property {InstanceTransformer} [transformer] Optional function to transform the instance before assignment.\n * @typedef InjectOptions\n * @memberOf module:injectable-decorators\n */\nexport type InjectOptions = {\n  args?: any[];\n  transformer?: InstanceTransformer;\n};\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 * @return {function(any, any): void} A property decorator function that sets up the dependency injection.\n *\n * @function inject\n */\nexport function inject(): (target: any, propertyKey: any) => void;\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 * @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 * @return {function(any, any): void} A property decorator function that sets up the dependency injection.\n *\n * @function inject\n */\nexport function inject(\n  category: string | Constructor\n): (target: any, propertyKey: any) => void;\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 * @param {Partial<InjectOptions>} [cfg={}] Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand\n * @return {function(any, any): void} A property decorator function that sets up the dependency injection.\n *\n * @function inject\n */\nexport function inject(\n  cfg: Partial<InjectOptions>\n): (target: any, propertyKey: any) => void;\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 * @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 {Partial<InjectOptions>} cfg={} Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand\n * @return {function(any, any): void} A property decorator function that sets up the dependency injection.\n *\n * @function inject\n */\nexport function inject(\n  category: string | Constructor,\n  cfg: Partial<InjectOptions>\n): (target: any, propertyKey: any) => void;\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 {Partial<InjectOptions>} [cfg={}] Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand\n * @return {function(any, any): void} 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 | Constructor | Partial<InjectOptions>,\n  cfg?: Partial<InjectOptions>\n) {\n  return (target: any, propertyKey: any) => {\n    const config: InjectOptions = (\n      cfg || typeof category === \"object\" ? category : {}\n    ) as InjectOptions;\n\n    const name: symbol | string | Constructor | undefined =\n      (typeof category !== \"object\" &&\n        (category as symbol | string | Constructor)) ||\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    const values = new WeakMap();\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          // let /obj: any;\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get(this: any) {\n              let obj = values.get(this);\n              if (obj) return obj;\n              obj = Injectables.get(name, ...(config.args || []));\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 (config.transformer)\n                try {\n                  obj = config.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

@@ -18,4 +18,4 @@ export * from "./utils";
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export declare const VERSION = "1.6.7";
+export declare const VERSION = "1.6.9";

package/lib/esm/index.js

@@ -18,5 +18,5 @@ export * from "./utils.js";
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export const VERSION = "1.6.7";
+export const VERSION = "1.6.9";
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFDN0IsaUNBQThCO0FBQzlCLDhCQUEyQjtBQUMzQiwyQkFBd0I7QUFDeEIsMkJBQXdCO0FBRXhCOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIEEgbGlnaHR3ZWlnaHQgZGVwZW5kZW5jeSBpbmplY3Rpb24gbGlicmFyeSBmb3IgVHlwZVNjcmlwdCBhcHBsaWNhdGlvbnMuXG4gKiBAc3VtbWFyeSBBZGRzIGEgc2ltcGxlIEluamVjdGFibGVzIGltcGxlbWVudGF0aW9uIHRvIGNyZWF0ZSBzaW5nbGV0b24gaW5zdGFuY2VzIG9mIGFuIG9iamVjdFxuICogYW5kIGVhc2lseSBpbmplY3QgaXQgaW50byBvdGhlciBvYmplY3RzLiBQcm92aWRlcyBkZWNvcmF0b3JzIGZvciBtYXJraW5nIGNsYXNzZXMgYXMgaW5qZWN0YWJsZVxuICogYW5kIGZvciBpbmplY3RpbmcgZGVwZW5kZW5jaWVzIGludG8gY2xhc3MgcHJvcGVydGllcy5cbiAqXG4gKiBAbW9kdWxlIGluamVjdGFibGUtZGVjb3JhdG9yc1xuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vSW5qZWN0YWJsZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3JlZ2lzdHJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ3VycmVudCB2ZXJzaW9uIG9mIHRoZSBpbmplY3RhYmxlLWRlY29yYXRvcnMgbGlicmFyeS5cbiAqIEBzdW1tYXJ5IERlZmluZWQgb24gbGlicmFyeSBidWlsZC4gSG9sZHMgdGhlIGxpYnJhcnkncyBjdXJyZW50IHZlcnNpb24gc3RyaW5nLlxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6aW5qZWN0YWJsZS1kZWNvcmF0b3JzXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19