@decaf-ts/injectable-decorators 1.6.8 → 1.6.10

package/lib/decorators.cjs

@@ -1,51 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectableBaseDecorator = injectableBaseDecorator;
 exports.injectable = injectable;
 exports.singleton = singleton;
 exports.onDemand = onDemand;
+exports.injectBaseDecorator = injectBaseDecorator;
 exports.inject = inject;
 const constants_1 = require("./constants.cjs");
 const Injectables_1 = require("./Injectables.cjs");
 const utils_1 = require("./utils.cjs");
-/**
- * @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
- */
-function injectable(category, cfg) {
+const decoration_1 = require("@decaf-ts/decoration");
+function injectableBaseDecorator(category, cfg) {
     cfg =
         cfg ||
             (typeof category === "object"
@@ -59,7 +24,7 @@ function injectable(category, cfg) {
                 : typeof category === "function" && category.name
                     ? category
                     : undefined;
-    return (original) => {
+    return function injectableInnerDecorator(original) {
         const symbol = Symbol.for(category || original.toString());
         category = category || original.name;
         const metadata = {
@@ -87,12 +52,55 @@ function injectable(category, cfg) {
         return newConstructor;
     };
 }
+/**
+ * @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
+ */
+function injectable(category, cfg) {
+    return decoration_1.Decoration.for(constants_1.InjectablesKeys.INJECTABLE)
+        .define({ decorator: injectableBaseDecorator, args: [category, cfg] })
+        .apply();
+}
 /**
  * @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.
+ * @return {function(any): any} A class decorator that registers the target as a singleton injectable.
  * @function singleton
  * @category Class Decorators
  */
@@ -111,6 +119,53 @@ function singleton(category, cfg) {
 function onDemand(category, cfg) {
     return injectable(category, Object.assign({}, cfg || {}, { singleton: false }));
 }
+function injectBaseDecorator(category, cfg) {
+    return function injectableInnerDecorator(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`);
+        }
+        // prop()(target, propertyKey);
+        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)
+                                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;
+                        },
+                    });
+                    return this[propertyKey];
+                }
+            },
+        });
+    };
+}
 /**
  * @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.
@@ -171,49 +226,8 @@ function onDemand(category, cfg) {
  *   end
  */
 function inject(category, cfg) {
-    return (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, 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)
-                                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;
-                        },
-                    });
-                    return this[propertyKey];
-                }
-            },
-        });
-    };
+    return decoration_1.Decoration.for(constants_1.InjectablesKeys.INJECT)
+        .define({ decorator: injectBaseDecorator, args: [category, cfg] })
+        .apply();
 }
-//# 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"]}
+//# 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\";\nimport { Decoration } from \"@decaf-ts/decoration\";\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\nexport function injectableBaseDecorator(\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  return function injectableInnerDecorator(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 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  return Decoration.for(InjectablesKeys.INJECTABLE)\n    .define({ decorator: injectableBaseDecorator, args: [category, cfg] })\n    .apply();\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\nexport function injectBaseDecorator(\n  category?: symbol | string | Constructor | Partial<InjectOptions>,\n  cfg?: Partial<InjectOptions>\n) {\n  return function injectableInnerDecorator(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    // prop()(target, propertyKey);\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\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 Decoration.for(InjectablesKeys.INJECT)\n    .define({ decorator: injectBaseDecorator, args: [category, cfg] })\n    .apply();\n}\n"]}

package/lib/decorators.d.ts

@@ -12,6 +12,7 @@ export type InjectableConfig = {
     singleton: boolean;
     callback?: InstanceCallback<any>;
 };
+export declare function injectableBaseDecorator(category?: string | Constructor | Partial<InjectableConfig>, cfg?: Partial<InjectableConfig>): (original: any) => 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.
@@ -35,7 +36,6 @@ export type Constructor<T = any> = {
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(): (original: any) => any;
 /**
@@ -49,7 +49,6 @@ export declare function injectable(): (original: any) => any;
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(category: string | Constructor): (original: any) => any;
 /**
@@ -62,7 +61,6 @@ export declare function injectable(category: string | Constructor): (original: a
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(cfg: Partial<InjectableConfig>): (original: any) => any;
 /**
@@ -77,7 +75,6 @@ export declare function injectable(cfg: Partial<InjectableConfig>): (original: a
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(category: string | Constructor, cfg: Partial<InjectableConfig>): (original: any) => any;
 /**
@@ -85,7 +82,7 @@ export declare function injectable(category: string | Constructor, cfg: Partial<
  * @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.
+ * @return {function(any): any} A class decorator that registers the target as a singleton injectable.
  * @function singleton
  * @category Class Decorators
  */
@@ -125,6 +122,7 @@ export type InjectOptions = {
     args?: any[];
     transformer?: InstanceTransformer;
 };
+export declare function injectBaseDecorator(category?: symbol | string | Constructor | Partial<InjectOptions>, 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.
@@ -133,7 +131,6 @@ export type InjectOptions = {
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(): (target: any, propertyKey: any) => void;
 /**
@@ -146,7 +143,6 @@ export declare function inject(): (target: any, propertyKey: any) => void;
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(category: string | Constructor): (target: any, propertyKey: any) => void;
 /**
@@ -158,7 +154,6 @@ export declare function inject(category: string | Constructor): (target: any, pr
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;
 /**
@@ -172,6 +167,5 @@ export declare function inject(cfg: Partial<InjectOptions>): (target: any, prope
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(category: string | Constructor, cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;

package/lib/esm/Metadata.d.ts

@@ -0,0 +1,8 @@
+import type { Constructor } from "@decaf-ts/decoration";
+import { InjectOptions } from "./decorators";
+declare module "@decaf-ts/decoration" {
+    namespace Metadata {
+        function injectables<T extends string | symbol | Constructor>(category?: T): (T extends undefined ? Constructor[] : Constructor) | undefined;
+        function injected<T, K extends keyof T>(model: T | Constructor<T>, prop?: K): (K extends keyof T ? InjectOptions : Record<K, InjectOptions>) | undefined;
+    }
+}

package/lib/esm/Metadata.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWV0YWRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvTWV0YWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQ29uc3RydWN0b3IgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRpb25cIjtcbmltcG9ydCB7IEluamVjdE9wdGlvbnMgfSBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5cbmRlY2xhcmUgbW9kdWxlIFwiQGRlY2FmLXRzL2RlY29yYXRpb25cIiB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tbmFtZXNwYWNlXG4gIGV4cG9ydCBuYW1lc3BhY2UgTWV0YWRhdGEge1xuICAgIGZ1bmN0aW9uIGluamVjdGFibGVzPFQgZXh0ZW5kcyBzdHJpbmcgfCBzeW1ib2wgfCBDb25zdHJ1Y3Rvcj4oXG4gICAgICBjYXRlZ29yeT86IFRcbiAgICApOiAoVCBleHRlbmRzIHVuZGVmaW5lZCA/IENvbnN0cnVjdG9yW10gOiBDb25zdHJ1Y3RvcikgfCB1bmRlZmluZWQ7XG5cbiAgICBmdW5jdGlvbiBpbmplY3RlZDxULCBLIGV4dGVuZHMga2V5b2YgVD4oXG4gICAgICBtb2RlbDogVCB8IENvbnN0cnVjdG9yPFQ+LFxuICAgICAgcHJvcD86IEtcbiAgICApOlxuICAgICAgfCAoSyBleHRlbmRzIGtleW9mIFQgPyBJbmplY3RPcHRpb25zIDogUmVjb3JkPEssIEluamVjdE9wdGlvbnM+KVxuICAgICAgfCB1bmRlZmluZWQ7XG4gIH1cbn1cbiJdfQ==

package/lib/esm/decorators.d.ts

@@ -12,6 +12,7 @@ export type InjectableConfig = {
     singleton: boolean;
     callback?: InstanceCallback<any>;
 };
+export declare function injectableBaseDecorator(category?: string | Constructor | Partial<InjectableConfig>, cfg?: Partial<InjectableConfig>): (original: any) => 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.
@@ -35,7 +36,6 @@ export type Constructor<T = any> = {
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(): (original: any) => any;
 /**
@@ -49,7 +49,6 @@ export declare function injectable(): (original: any) => any;
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(category: string | Constructor): (original: any) => any;
 /**
@@ -62,7 +61,6 @@ export declare function injectable(category: string | Constructor): (original: a
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(cfg: Partial<InjectableConfig>): (original: any) => any;
 /**
@@ -77,7 +75,6 @@ export declare function injectable(cfg: Partial<InjectableConfig>): (original: a
  * @return {function(any): any} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
- * @category Decorators
  */
 export declare function injectable(category: string | Constructor, cfg: Partial<InjectableConfig>): (original: any) => any;
 /**
@@ -85,7 +82,7 @@ export declare function injectable(category: string | Constructor, cfg: Partial<
  * @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.
+ * @return {function(any): any} A class decorator that registers the target as a singleton injectable.
  * @function singleton
  * @category Class Decorators
  */
@@ -125,6 +122,7 @@ export type InjectOptions = {
     args?: any[];
     transformer?: InstanceTransformer;
 };
+export declare function injectBaseDecorator(category?: symbol | string | Constructor | Partial<InjectOptions>, 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.
@@ -133,7 +131,6 @@ export type InjectOptions = {
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(): (target: any, propertyKey: any) => void;
 /**
@@ -146,7 +143,6 @@ export declare function inject(): (target: any, propertyKey: any) => void;
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(category: string | Constructor): (target: any, propertyKey: any) => void;
 /**
@@ -158,7 +154,6 @@ export declare function inject(category: string | Constructor): (target: any, pr
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;
 /**
@@ -172,6 +167,5 @@ export declare function inject(cfg: Partial<InjectOptions>): (target: any, prope
  * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
  *
  * @function inject
- * @category Decorators
  */
 export declare function inject(category: string | Constructor, cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;