@decaf-ts/injectable-decorators 1.6.7 → 1.6.8

package/lib/constants.cjs

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectablesKeys = void 0;
+exports.TypeKey = exports.DefaultInjectablesConfig = exports.InjectablesKeys = void 0;
 /**
  * @description Constants used for reflection metadata keys in the dependency injection system.
  * @summary Injectables Reflection keys used to store and retrieve metadata about injectable classes and properties.
- *
  * @property {string} REFLECT Reflection injectables base key prefix for all metadata keys
  * @property {string} INJECTABLE Reflection key suffix for marking a class as injectable
  * @property {string} INJECT Reflection key suffix for marking a property for injection
- *
  * @const InjectablesKeys
  * @memberOf module:injectable-decorators
  */
@@ -17,4 +15,20 @@ exports.InjectablesKeys = {
     INJECTABLE: "injectable",
     INJECT: "inject",
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7Ozs7Ozs7OztHQVVHO0FBQ1UsUUFBQSxlQUFlLEdBQUc7SUFDN0IsT0FBTyxFQUFFLFlBQVk7SUFDckIsVUFBVSxFQUFFLFlBQVk7SUFDeEIsTUFBTSxFQUFFLFFBQVE7Q0FDakIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIENvbnN0YW50cyB1c2VkIGZvciByZWZsZWN0aW9uIG1ldGFkYXRhIGtleXMgaW4gdGhlIGRlcGVuZGVuY3kgaW5qZWN0aW9uIHN5c3RlbS5cbiAqIEBzdW1tYXJ5IEluamVjdGFibGVzIFJlZmxlY3Rpb24ga2V5cyB1c2VkIHRvIHN0b3JlIGFuZCByZXRyaWV2ZSBtZXRhZGF0YSBhYm91dCBpbmplY3RhYmxlIGNsYXNzZXMgYW5kIHByb3BlcnRpZXMuXG4gKiBcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBSRUZMRUNUIFJlZmxlY3Rpb24gaW5qZWN0YWJsZXMgYmFzZSBrZXkgcHJlZml4IGZvciBhbGwgbWV0YWRhdGEga2V5c1xuICogQHByb3BlcnR5IHtzdHJpbmd9IElOSkVDVEFCTEUgUmVmbGVjdGlvbiBrZXkgc3VmZml4IGZvciBtYXJraW5nIGEgY2xhc3MgYXMgaW5qZWN0YWJsZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IElOSkVDVCBSZWZsZWN0aW9uIGtleSBzdWZmaXggZm9yIG1hcmtpbmcgYSBwcm9wZXJ0eSBmb3IgaW5qZWN0aW9uXG4gKiBcbiAqIEBjb25zdCBJbmplY3RhYmxlc0tleXNcbiAqIEBtZW1iZXJPZiBtb2R1bGU6aW5qZWN0YWJsZS1kZWNvcmF0b3JzXG4gKi9cbmV4cG9ydCBjb25zdCBJbmplY3RhYmxlc0tleXMgPSB7XG4gIFJFRkxFQ1Q6IFwiaW5qZWN0LmRiLlwiLFxuICBJTkpFQ1RBQkxFOiBcImluamVjdGFibGVcIixcbiAgSU5KRUNUOiBcImluamVjdFwiLFxufTtcbiJdfQ==
+/**
+ * @description Default configuration applied by the @injectable decorator when none is provided.
+ * @summary Sets sensible defaults such as singleton lifecycle for newly registered injectables.
+ * @const DefaultInjectablesConfig
+ * @memberOf module:injectable-decorators
+ */
+exports.DefaultInjectablesConfig = {
+    singleton: true,
+};
+/**
+ * @description Reflection metadata key for accessing TypeScript type information.
+ * @summary Holds the key for retrieving the design type from TypeScript's reflection metadata.
+ * @const TypeKey
+ * @memberOf module:injectable-decorators
+ */
+exports.TypeKey = "design:type";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constants.d.ts

@@ -1,11 +1,10 @@
+import { InjectableConfig } from "./decorators";
 /**
  * @description Constants used for reflection metadata keys in the dependency injection system.
  * @summary Injectables Reflection keys used to store and retrieve metadata about injectable classes and properties.
- *
  * @property {string} REFLECT Reflection injectables base key prefix for all metadata keys
  * @property {string} INJECTABLE Reflection key suffix for marking a class as injectable
  * @property {string} INJECT Reflection key suffix for marking a property for injection
- *
  * @const InjectablesKeys
  * @memberOf module:injectable-decorators
  */
@@ -14,3 +13,17 @@ export declare const InjectablesKeys: {
     INJECTABLE: string;
     INJECT: string;
 };
+/**
+ * @description Default configuration applied by the @injectable decorator when none is provided.
+ * @summary Sets sensible defaults such as singleton lifecycle for newly registered injectables.
+ * @const DefaultInjectablesConfig
+ * @memberOf module:injectable-decorators
+ */
+export declare const DefaultInjectablesConfig: InjectableConfig;
+/**
+ * @description Reflection metadata key for accessing TypeScript type information.
+ * @summary Holds the key for retrieving the design type from TypeScript's reflection metadata.
+ * @const TypeKey
+ * @memberOf module:injectable-decorators
+ */
+export declare const TypeKey = "design:type";

package/lib/decorators.cjs

@@ -1,38 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInjectKey = void 0;
 exports.injectable = injectable;
+exports.singleton = singleton;
+exports.onDemand = onDemand;
 exports.inject = inject;
 const constants_1 = require("./constants.cjs");
 const Injectables_1 = require("./Injectables.cjs");
 const utils_1 = require("./utils.cjs");
 /**
- * @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 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
  */
-const getInjectKey = (key) => constants_1.InjectablesKeys.REFLECT + key;
-exports.getInjectKey = getInjectKey;
-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;
+function injectable(category, cfg) {
+    cfg =
+        cfg ||
+            (typeof category === "object"
+                ? Object.assign(category, constants_1.DefaultInjectablesConfig)
+                : constants_1.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((0, exports.getInjectKey)(constants_1.InjectablesKeys.INJECTABLE), metadata, original);
+        Reflect.defineMetadata((0, utils_1.getInjectKey)(constants_1.InjectablesKeys.INJECTABLE), metadata, original);
         // the new constructor behaviour
         const newConstructor = function (...args) {
             return Injectables_1.Injectables.get(symbol, ...args);
@@ -47,16 +81,36 @@ function injectable(name, cb) {
             configurable: false,
             value: original.prototype.constructor.name,
         });
-        const opts = {
-            singleton: true,
-            callback: instanceCallback,
-        };
-        Reflect.defineMetadata((0, exports.getInjectKey)(constants_1.InjectablesKeys.INJECTABLE), metadata, newConstructor);
-        Injectables_1.Injectables.register(original, symbol, opts);
+        Reflect.defineMetadata((0, utils_1.getInjectKey)(constants_1.InjectablesKeys.INJECTABLE), metadata, newConstructor);
+        Injectables_1.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
+ */
+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
+ */
+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.
@@ -80,8 +134,8 @@ 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
@@ -116,39 +170,43 @@ function injectable(name, cb) {
  *     end
  *   end
  */
-function inject(category, transformer, ...args) {
+function inject(category, cfg) {
     return (target, propertyKey) => {
-        const values = new WeakMap();
-        const name = category || (0, utils_1.getTypeFromDecorator)(target, propertyKey);
+        const config = (cfg || typeof category === "object" ? category : {});
+        const name = (typeof category !== "object" &&
+            category) ||
+            (0, utils_1.getTypeFromDecorator)(target, propertyKey);
         if (!name) {
             throw new Error(`Could not get Type from decorator`);
         }
-        Reflect.defineMetadata((0, exports.getInjectKey)(constants_1.InjectablesKeys.INJECT), {
+        Reflect.defineMetadata((0, utils_1.getInjectKey)(constants_1.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_1.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_1.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;
                         },
                     });
@@ -158,4 +216,4 @@ 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 * @category Decorators\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 * @category Decorators\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 * @category Decorators\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 * @category Decorators\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 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 * @category Decorators\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 * @category Decorators\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 * @category Decorators\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 * @category Decorators\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"]}