@decaf-ts/injectable-decorators 1.6.1 → 1.6.2

package/lib/esm/decorators.js

@@ -1,70 +1,98 @@
-import { InjectablesKeys } from "./constants";
-import { Injectables } from "./Injectables";
-import { getTypeFromDecorator } from "./utils";
+import { InjectablesKeys } from "./constants.js";
+import { Injectables } from "./Injectables.js";
+import { getTypeFromDecorator } from "./utils.js";
 /**
- * @summary Return the reflection key for injectables
- *
- * @param {string} key
+ * @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
  */
 const getInjectKey = (key) => InjectablesKeys.REFLECT + key;
 /**
- * @summary Defines a class as an injectable
+ * @description Decorator that marks a class as available for dependency injection.
+ * @summary Defines a class as an injectable singleton that can be retrieved from the registry.
+ * When applied to a class, replaces its constructor with one that returns a singleton instance.
  *
- * @param {string} [category] defaults to the class Name. (Useful when minification occours and names are changed so we can no longer rely on the class name, or when we want to upcast the Object)
- * @param {boolean} [force] defines if the injectable should override the already existing instance (if any). (only meant for extending decorators
- * @param instanceCallback
+ * @param {string} [category] Defaults to the class name. Useful when minification occurs and names are changed,
+ * or when you want to upcast the object to a different type.
+ * @param {boolean} [force] Defines if the injectable should override an already existing instance (if any).
+ * Only meant for extending decorators.
+ * @param {Function} [instanceCallback] Optional callback function that will be called with the instance after creation.
+ * @return {Function} A decorator function that transforms the class into an injectable.
  *
  * @function injectable
+ * @category Class Decorators
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Decorator
+ *   participant Injectables
+ *
+ *   Client->>Decorator: @injectable()
+ *   Decorator->>Decorator: Create new constructor
  *
- * @memberOf module:injectable-decorators.Decorators
+ *   Note over Decorator: When new instance requested
+ *   Decorator->>Injectables: get(name)
+ *   alt Instance exists
+ *     Injectables-->>Decorator: Return existing instance
+ *   else No instance
+ *     Decorator->>Injectables: register(original, name)
+ *     Decorator->>Injectables: get(name)
+ *     Injectables-->>Decorator: Return new instance
+ *     opt Has callback
+ *       Decorator->>Decorator: Call instanceCallback
+ *     end
+ *   end
+ *   Decorator->>Decorator: Define metadata
+ *   Decorator-->>Client: Return instance
  */
-export const injectable = (category = undefined, force = false, instanceCallback) => 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-(original, propertyKey) => {
-    const name = category || original.name;
-    // the new constructor behaviour
-    const newConstructor = function (...args) {
-        let inj = Injectables.get(name, ...args);
-        if (!inj) {
-            Injectables.register(original, name, true, force);
-            inj = Injectables.get(name, ...args);
-            if (!inj)
-                return undefined;
-            if (instanceCallback)
-                try {
-                    instanceCallback(inj);
-                }
-                catch (e) {
-                    console.error(`Failed to call injectable callback for ${name}: ${e}`);
-                }
-        }
-        const metadata = Object.assign({}, {
-            class: name,
+export function injectable(category = undefined, force = false, instanceCallback) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return (original, propertyKey) => {
+        const name = category || original.name;
+        // the new constructor behaviour
+        const newConstructor = function (...args) {
+            let inj = Injectables.get(name, ...args);
+            if (!inj) {
+                Injectables.register(original, name, true, force);
+                inj = Injectables.get(name, ...args);
+                if (!inj)
+                    return undefined;
+                if (instanceCallback)
+                    try {
+                        instanceCallback(inj);
+                    }
+                    catch (e) {
+                        console.error(`Failed to call injectable callback for ${name}: ${e}`);
+                    }
+            }
+            const metadata = Object.assign({}, {
+                class: name,
+            });
+            Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECTABLE), metadata, inj.constructor);
+            return inj;
+        };
+        // copy prototype so instanceof operator still works
+        newConstructor.prototype = original.prototype;
+        // newConstructor.__proto__ = original.__proto__;
+        // Sets the proper constructor name for type verification
+        Object.defineProperty(newConstructor, "name", {
+            writable: false,
+            enumerable: true,
+            configurable: false,
+            value: original.prototype.constructor.name,
         });
-        Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECTABLE), metadata, inj.constructor);
-        return inj;
+        // return new constructor (will override original)
+        return newConstructor;
     };
-    // copy prototype so instanceof operator still works
-    newConstructor.prototype = original.prototype;
-    // newConstructor.__proto__ = original.__proto__;
-    // Sets the proper constructor name for type verification
-    Object.defineProperty(newConstructor, "name", {
-        writable: false,
-        enumerable: true,
-        configurable: false,
-        value: original.prototype.constructor.name,
-    });
-    // return new constructor (will override original)
-    return newConstructor;
-};
+}
 /**
- * @summary Allows for the injection of an {@link injectable} decorated dependency
- * @description the property must be typed for the requested dependency.
- *
- * Only concrete classes. No generics are supported
+ * @description Property decorator that injects a dependency into a class property.
+ * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
+ * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
  *
  * Injected properties should be described like so:
  * <pre>
@@ -79,53 +107,86 @@ export const injectable = (category = undefined, force = false, instanceCallback
  * </pre>
  *
  * where InjectableClass is the class you want to inject.
- * Notice the use of '!:' to ensure the transpiler the property will be set outside the constructor but will always be defined
- * For project where minification occours, you should use the category param to ensure the name is the same throughout
+ * Notice the use of '!:' to ensure the transpiler the property will be set outside the constructor but will always be defined.
+ * For projects where minification occurs, you should use the category param to ensure the name is the same throughout.
  *
- * @param {string} [category] defaults to the class Name. (Useful when minification occours and names are changed so we can no longer rely on the class name, or when we want to upcast the Object)
- * @param {InstanceTransformer} [transformer]
+ * @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.
  *
  * @function inject
+ * @category Property Decorators
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Decorator
+ *   participant Injectables
  *
- * @memberOf module:injectable-decorators.Decorators
+ *   Client->>Decorator: @inject()
+ *   Decorator->>Decorator: Get type from property
+ *   Decorator->>Decorator: Define metadata
+ *   Decorator->>Decorator: Define property getter
+ *
+ *   Note over Decorator: When property accessed
+ *   Client->>Decorator: access property
+ *   Decorator->>Decorator: Check if instance exists
+ *   alt Instance exists in WeakMap
+ *     Decorator-->>Client: Return cached instance
+ *   else No instance
+ *     Decorator->>Injectables: get(name)
+ *     alt Injectable found
+ *       Injectables-->>Decorator: Return injectable instance
+ *       opt Has transformer
+ *         Decorator->>Decorator: Call transformer
+ *       end
+ *       Decorator->>Decorator: Store in WeakMap
+ *       Decorator-->>Client: Return instance
+ *     else No injectable
+ *       Decorator-->>Client: Throw error
+ *     end
+ *   end
  */
-export const inject = (category, transformer) => (target, propertyKey) => {
-    const values = new WeakMap();
-    const name = category || getTypeFromDecorator(target, propertyKey);
-    if (!name)
-        throw new Error(`Could not get Type from decorator`);
-    Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECT), {
-        injectable: name,
-    }, target, propertyKey);
-    Object.defineProperty(target, propertyKey, {
-        configurable: true,
-        get() {
-            const descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
-            if (descriptor.configurable) {
-                Object.defineProperty(this, propertyKey, {
-                    enumerable: true,
-                    configurable: false,
-                    get() {
-                        let obj = values.get(this);
-                        if (!obj) {
-                            obj = Injectables.get(name);
-                            if (!obj)
-                                throw new Error(`Could not get Injectable ${name} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`);
-                            if (transformer)
-                                try {
-                                    obj = transformer(obj, target);
-                                }
-                                catch (e) {
-                                    console.error(e);
-                                }
-                            values.set(this, obj);
-                        }
-                        return obj;
-                    },
-                });
-                return this[propertyKey];
-            }
-        },
-    });
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { InjectablesKeys } from \"./constants\";\nimport { Injectables } from \"./Injectables\";\nimport { getTypeFromDecorator } from \"./utils\";\n\n/**\n * @summary Return the reflection key for injectables\n *\n * @param {string} key\n * @function getInjectKey\n *\n * @memberOf module:injectable-decorators\n */\nconst getInjectKey = (key: string) => InjectablesKeys.REFLECT + key;\n\n/**\n * @summary Defines a class as an injectable\n *\n * @param {string} [category] defaults to the class Name. (Useful when minification occours and names are changed so we can no longer rely on the class name, or when we want to upcast the Object)\n * @param {boolean} [force] defines if the injectable should override the already existing instance (if any). (only meant for extending decorators\n * @param instanceCallback\n *\n * @function injectable\n *\n * @memberOf module:injectable-decorators.Decorators\n */\nexport const injectable =\n  (\n    category: string | undefined = undefined,\n    force: boolean = false,\n    instanceCallback?: (instance: any, ...args: any[]) => void\n  ) =>\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  (original: any, propertyKey?: any) => {\n    const name = category || original.name;\n    // the new constructor behaviour\n    const newConstructor: any = function (...args: any[]) {\n      let inj: any = Injectables.get<any>(name, ...args);\n      if (!inj) {\n        Injectables.register(original, name, true, force);\n        inj = Injectables.get<any>(name, ...args);\n        if (!inj) return undefined;\n\n        if (instanceCallback)\n          try {\n            instanceCallback(inj);\n          } catch (e: any) {\n            console.error(\n              `Failed to call injectable callback for ${name}: ${e}`\n            );\n          }\n      }\n\n      const metadata = Object.assign(\n        {},\n        {\n          class: name,\n        }\n      );\n\n      Reflect.defineMetadata(\n        getInjectKey(InjectablesKeys.INJECTABLE),\n        metadata,\n        inj.constructor\n      );\n\n      return inj;\n    };\n\n    // copy prototype so instanceof operator still works\n    newConstructor.prototype = original.prototype;\n    // newConstructor.__proto__ = original.__proto__;\n    // Sets the proper constructor name for type verification\n    Object.defineProperty(newConstructor, \"name\", {\n      writable: false,\n      enumerable: true,\n      configurable: false,\n      value: original.prototype.constructor.name,\n    });\n    // return new constructor (will override original)\n    return newConstructor;\n  };\n\n/**\n * @summary function witch transforms a cached {@link injectable}\n *\n * @param {any} injectable\n * @param {any} obj the obj the injectable will be injected on\n *\n * @memberOf module:injectable-decorators\n */\nexport type InstanceTransformer = (injectable: any, obj: any) => any;\n\n/**\n * @summary Allows for the injection of an {@link injectable} decorated dependency\n * @description the property must be typed for the requested dependency.\n *\n * Only concrete classes. No generics are supported\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 project where minification occours, you should use the category param to ensure the name is the same throughout\n *\n * @param {string} [category] defaults to the class Name. (Useful when minification occours and names are changed so we can no longer rely on the class name, or when we want to upcast the Object)\n * @param {InstanceTransformer} [transformer]\n *\n * @function inject\n *\n * @memberOf module:injectable-decorators.Decorators\n */\nexport const inject =\n  (category?: string, transformer?: InstanceTransformer) =>\n  (target: any, propertyKey?: any) => {\n    const values = new WeakMap();\n\n    const name: string | undefined =\n      category || getTypeFromDecorator(target, propertyKey);\n    if (!name) throw new Error(`Could not get Type from decorator`);\n\n    Reflect.defineMetadata(\n      getInjectKey(InjectablesKeys.INJECT),\n      {\n        injectable: name,\n      },\n      target,\n      propertyKey\n    );\n\n    Object.defineProperty(target, propertyKey, {\n      configurable: true,\n      get(this: any) {\n        const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(\n          target,\n          propertyKey\n        ) as PropertyDescriptor;\n        if (descriptor.configurable) {\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get(this: any) {\n              let obj = values.get(this);\n              if (!obj) {\n                obj = Injectables.get(name);\n                if (!obj)\n                  throw new Error(\n                    `Could not get Injectable ${name} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`\n                  );\n                if (transformer)\n                  try {\n                    obj = transformer(obj, target);\n                  } catch (e) {\n                    console.error(e);\n                  }\n                values.set(this, obj);\n              }\n              return obj;\n            },\n          });\n          return this[propertyKey];\n        }\n      },\n    });\n  };\n"]}
+export function inject(category, transformer) {
+    return (target, propertyKey) => {
+        const values = new WeakMap();
+        const name = category || getTypeFromDecorator(target, propertyKey);
+        if (!name)
+            throw new Error(`Could not get Type from decorator`);
+        Reflect.defineMetadata(getInjectKey(InjectablesKeys.INJECT), {
+            injectable: name,
+        }, target, propertyKey);
+        Object.defineProperty(target, propertyKey, {
+            configurable: true,
+            get() {
+                const descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
+                if (descriptor.configurable) {
+                    Object.defineProperty(this, propertyKey, {
+                        enumerable: true,
+                        configurable: false,
+                        get() {
+                            let obj = values.get(this);
+                            if (!obj) {
+                                obj = Injectables.get(name);
+                                if (!obj)
+                                    throw new Error(`Could not get Injectable ${name} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`);
+                                if (transformer)
+                                    try {
+                                        obj = transformer(obj, target);
+                                    }
+                                    catch (e) {
+                                        console.error(e);
+                                    }
+                                values.set(this, obj);
+                            }
+                            return obj;
+                        },
+                    });
+                    return this[propertyKey];
+                }
+            },
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { InjectablesKeys } from \"./constants\";\nimport { Injectables } from \"./Injectables\";\nimport { getTypeFromDecorator } from \"./utils\";\n\n/**\n * @description Generates a fully qualified reflection metadata key.\n * @summary Returns the reflection key for injectables by prefixing the provided key with the base reflection key.\n * @param {string} key The key to be prefixed\n * @return {string} The fully qualified reflection key\n * @function getInjectKey\n * @memberOf module:injectable-decorators\n */\nconst getInjectKey = (key: string) => InjectablesKeys.REFLECT + key;\n\n/**\n * @description Decorator that marks a class as available for dependency injection.\n * @summary Defines a class as an injectable singleton that can be retrieved from the registry.\n * When applied to a class, replaces its constructor with one that returns a singleton instance.\n *\n * @param {string} [category] Defaults to the class name. Useful when minification occurs and names are changed,\n * or when you want to upcast the object to a different type.\n * @param {boolean} [force] Defines if the injectable should override an already existing instance (if any).\n * Only meant for extending decorators.\n * @param {Function} [instanceCallback] Optional callback function that will be called with the instance after creation.\n * @return {Function} A decorator function that transforms the class into an injectable.\n *\n * @function injectable\n * @category Class Decorators\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator\n *   participant Injectables\n *\n *   Client->>Decorator: @injectable()\n *   Decorator->>Decorator: Create new constructor\n *\n *   Note over Decorator: When new instance requested\n *   Decorator->>Injectables: get(name)\n *   alt Instance exists\n *     Injectables-->>Decorator: Return existing instance\n *   else No instance\n *     Decorator->>Injectables: register(original, name)\n *     Decorator->>Injectables: get(name)\n *     Injectables-->>Decorator: Return new instance\n *     opt Has callback\n *       Decorator->>Decorator: Call instanceCallback\n *     end\n *   end\n *   Decorator->>Decorator: Define metadata\n *   Decorator-->>Client: Return instance\n */\nexport function injectable(\n  category: string | undefined = undefined,\n  force: boolean = false,\n  instanceCallback?: (instance: any, ...args: any[]) => void\n) {\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  return (original: any, propertyKey?: any) => {\n    const name = category || original.name;\n    // the new constructor behaviour\n    const newConstructor: any = function (...args: any[]) {\n      let inj: any = Injectables.get<any>(name, ...args);\n      if (!inj) {\n        Injectables.register(original, name, true, force);\n        inj = Injectables.get<any>(name, ...args);\n        if (!inj) return undefined;\n\n        if (instanceCallback)\n          try {\n            instanceCallback(inj);\n          } catch (e: any) {\n            console.error(\n              `Failed to call injectable callback for ${name}: ${e}`\n            );\n          }\n      }\n\n      const metadata = Object.assign(\n        {},\n        {\n          class: name,\n        }\n      );\n\n      Reflect.defineMetadata(\n        getInjectKey(InjectablesKeys.INJECTABLE),\n        metadata,\n        inj.constructor\n      );\n\n      return inj;\n    };\n\n    // copy prototype so instanceof operator still works\n    newConstructor.prototype = original.prototype;\n    // newConstructor.__proto__ = original.__proto__;\n    // Sets the proper constructor name for type verification\n    Object.defineProperty(newConstructor, \"name\", {\n      writable: false,\n      enumerable: true,\n      configurable: false,\n      value: original.prototype.constructor.name,\n    });\n    // return new constructor (will override original)\n    return newConstructor;\n  };\n}\n/**\n * @description Function type for transforming injectable instances before they're injected.\n * @summary Function which transforms a cached {@link injectable} instance before it's injected into a target object.\n *\n * @param {any} injectable The injectable instance to transform\n * @param {any} obj The object the injectable will be injected on\n * @return {any} The transformed injectable instance\n *\n * @typedef {Function} InstanceTransformer\n * @memberOf module:injectable-decorators\n */\nexport type InstanceTransformer = (injectable: any, obj: any) => any;\n\n/**\n * @description Property decorator that injects a dependency into a class property.\n * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.\n * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.\n *\n * Injected properties should be described like so:\n * <pre>\n *     class ClassName {\n *         ...\n *\n *         @inject()\n *         propertyName!: InjectableClass;\n *\n *         ...\n *     }\n * </pre>\n *\n * where InjectableClass is the class you want to inject.\n * Notice the use of '!:' to ensure the transpiler the property will be set outside the constructor but will always be defined.\n * For projects where minification occurs, you should use the category param to ensure the name is the same throughout.\n *\n * @param {string} [category] Defaults to the class name derived from the property type. Useful when minification occurs\n * and names are changed, or when you want to upcast the object to a different type.\n * @param {InstanceTransformer} [transformer] Optional function to transform the injectable instance before it's injected.\n * @return {Function} A property decorator function that sets up the dependency injection.\n *\n * @function inject\n * @category Property Decorators\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator\n *   participant Injectables\n *\n *   Client->>Decorator: @inject()\n *   Decorator->>Decorator: Get type from property\n *   Decorator->>Decorator: Define metadata\n *   Decorator->>Decorator: Define property getter\n *\n *   Note over Decorator: When property accessed\n *   Client->>Decorator: access property\n *   Decorator->>Decorator: Check if instance exists\n *   alt Instance exists in WeakMap\n *     Decorator-->>Client: Return cached instance\n *   else No instance\n *     Decorator->>Injectables: get(name)\n *     alt Injectable found\n *       Injectables-->>Decorator: Return injectable instance\n *       opt Has transformer\n *         Decorator->>Decorator: Call transformer\n *       end\n *       Decorator->>Decorator: Store in WeakMap\n *       Decorator-->>Client: Return instance\n *     else No injectable\n *       Decorator-->>Client: Throw error\n *     end\n *   end\n */\nexport function inject(category?: string, transformer?: InstanceTransformer) {\n  return (target: any, propertyKey?: any) => {\n    const values = new WeakMap();\n\n    const name: string | undefined =\n      category || getTypeFromDecorator(target, propertyKey);\n    if (!name) throw new Error(`Could not get Type from decorator`);\n\n    Reflect.defineMetadata(\n      getInjectKey(InjectablesKeys.INJECT),\n      {\n        injectable: name,\n      },\n      target,\n      propertyKey\n    );\n\n    Object.defineProperty(target, propertyKey, {\n      configurable: true,\n      get(this: any) {\n        const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(\n          target,\n          propertyKey\n        ) as PropertyDescriptor;\n        if (descriptor.configurable) {\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get(this: any) {\n              let obj = values.get(this);\n              if (!obj) {\n                obj = Injectables.get(name);\n                if (!obj)\n                  throw new Error(\n                    `Could not get Injectable ${name} to inject in ${target.constructor ? target.constructor.name : target.name}'s ${propertyKey}`\n                  );\n                if (transformer)\n                  try {\n                    obj = transformer(obj, target);\n                  } catch (e) {\n                    console.error(e);\n                  }\n                values.set(this, obj);\n              }\n              return obj;\n            },\n          });\n          return this[propertyKey];\n        }\n      },\n    });\n  };\n}\n"]}

package/lib/esm/index.d.ts

@@ -1,22 +1,20 @@
 /**
+ * @description A lightweight dependency injection library for TypeScript applications.
  * @summary Adds a simple Injectables implementation to create singleton instances of an object
- * and easily inject it into other objects
+ * and easily inject it into other objects. Provides decorators for marking classes as injectable
+ * and for injecting dependencies into class properties.
  *
  * @module injectable-decorators
  */
-/**
- * @summary functions that decorate classes or class properties
- * @namespace Decorators
- * @memberOf module:injectable-decorators
- */
 export * from "./constants";
 export * from "./decorators";
 export * from "./Injectables";
 export * from "./registry";
 export * from "./utils";
 /**
- * @summary Defined on library build. holds the library current version
+ * @description Current version of the injectable-decorators library.
+ * @summary Defined on library build. Holds the library's current version string.
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export declare const VERSION = "1.6.1";
+export declare const VERSION = "1.6.2";

package/lib/esm/index.js

@@ -1,23 +1,21 @@
 /**
+ * @description A lightweight dependency injection library for TypeScript applications.
  * @summary Adds a simple Injectables implementation to create singleton instances of an object
- * and easily inject it into other objects
+ * and easily inject it into other objects. Provides decorators for marking classes as injectable
+ * and for injecting dependencies into class properties.
  *
  * @module injectable-decorators
  */
+export * from "./constants.js";
+export * from "./decorators.js";
+export * from "./Injectables.js";
+export * from "./registry.js";
+export * from "./utils.js";
 /**
- * @summary functions that decorate classes or class properties
- * @namespace Decorators
- * @memberOf module:injectable-decorators
- */
-export * from "./constants";
-export * from "./decorators";
-export * from "./Injectables";
-export * from "./registry";
-export * from "./utils";
-/**
- * @summary Defined on library build. holds the library current version
+ * @description Current version of the injectable-decorators library.
+ * @summary Defined on library build. Holds the library's current version string.
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export const VERSION = "1.6.1";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFFSDs7OztHQUlHO0FBRUgsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxTQUFTLENBQUM7QUFFeEI7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBzdW1tYXJ5IEFkZHMgYSBzaW1wbGUgSW5qZWN0YWJsZXMgaW1wbGVtZW50YXRpb24gdG8gY3JlYXRlIHNpbmdsZXRvbiBpbnN0YW5jZXMgb2YgYW4gb2JqZWN0XG4gKiBhbmQgZWFzaWx5IGluamVjdCBpdCBpbnRvIG90aGVyIG9iamVjdHNcbiAqXG4gKiBAbW9kdWxlIGluamVjdGFibGUtZGVjb3JhdG9yc1xuICovXG5cbi8qKlxuICogQHN1bW1hcnkgZnVuY3Rpb25zIHRoYXQgZGVjb3JhdGUgY2xhc3NlcyBvciBjbGFzcyBwcm9wZXJ0aWVzXG4gKiBAbmFtZXNwYWNlIERlY29yYXRvcnNcbiAqIEBtZW1iZXJPZiBtb2R1bGU6aW5qZWN0YWJsZS1kZWNvcmF0b3JzXG4gKi9cblxuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9JbmplY3RhYmxlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVnaXN0cnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgRGVmaW5lZCBvbiBsaWJyYXJ5IGJ1aWxkLiBob2xkcyB0aGUgbGlicmFyeSBjdXJyZW50IHZlcnNpb25cbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmluamVjdGFibGUtZGVjb3JhdG9yc1xuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==
+export const VERSION = "1.6.2";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFDN0IsaUNBQThCO0FBQzlCLDhCQUEyQjtBQUMzQiwyQkFBd0I7QUFFeEI7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gQSBsaWdodHdlaWdodCBkZXBlbmRlbmN5IGluamVjdGlvbiBsaWJyYXJ5IGZvciBUeXBlU2NyaXB0IGFwcGxpY2F0aW9ucy5cbiAqIEBzdW1tYXJ5IEFkZHMgYSBzaW1wbGUgSW5qZWN0YWJsZXMgaW1wbGVtZW50YXRpb24gdG8gY3JlYXRlIHNpbmdsZXRvbiBpbnN0YW5jZXMgb2YgYW4gb2JqZWN0XG4gKiBhbmQgZWFzaWx5IGluamVjdCBpdCBpbnRvIG90aGVyIG9iamVjdHMuIFByb3ZpZGVzIGRlY29yYXRvcnMgZm9yIG1hcmtpbmcgY2xhc3NlcyBhcyBpbmplY3RhYmxlXG4gKiBhbmQgZm9yIGluamVjdGluZyBkZXBlbmRlbmNpZXMgaW50byBjbGFzcyBwcm9wZXJ0aWVzLlxuICpcbiAqIEBtb2R1bGUgaW5qZWN0YWJsZS1kZWNvcmF0b3JzXG4gKi9cblxuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9JbmplY3RhYmxlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVnaXN0cnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgaW5qZWN0YWJsZS1kZWNvcmF0b3JzIGxpYnJhcnkuXG4gKiBAc3VtbWFyeSBEZWZpbmVkIG9uIGxpYnJhcnkgYnVpbGQuIEhvbGRzIHRoZSBsaWJyYXJ5J3MgY3VycmVudCB2ZXJzaW9uIHN0cmluZy5cbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmluamVjdGFibGUtZGVjb3JhdG9yc1xuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==

package/lib/esm/registry.d.ts

@@ -1,46 +1,93 @@
 /**
- * @summary defines an Injectable type
+ * @description Type representing either a class constructor or an instance.
+ * @summary Defines an Injectable type that can be either a class constructor or an instance of a class.
+ * @template T The type of the injectable object
+ * @typedef {function(any): T | T} Injectable
  * @memberOf module:injectable-decorators
  */
 export type Injectable<T> = {
     new (...args: any[]): T;
 } | T;
 /**
- * @summary Interface for an injectable registry
- * @interface InjectableRegistry
+ * @description Contract for a registry that manages injectable objects.
+ * @summary Interface for an injectable registry that provides methods for retrieving, registering, and building injectable objects.
+ * @template T Type parameter used in the interface methods
+ * @interface InjectablesRegistry
+ * @memberOf module:injectable-decorators
  */
 export interface InjectablesRegistry {
     /**
-     * @summary retrieves an {@link Injectable}
-     * @param {string} name
-     * @param {any[]} args
-     * @return {Injectable | undefined}
-     *
-     * @method
+     * @description Fetches an injectable instance by its registered name.
+     * @summary Retrieves an {@link Injectable} from the registry by name, optionally passing constructor arguments.
+     * @template T Type of the injectable object to retrieve
+     * @param {string} name The registered name of the injectable to retrieve
+     * @param {any[]} args Constructor arguments to pass when instantiating the injectable
+     * @return {Injectable<T> | undefined} The injectable instance or undefined if not found
+     * @memberOf module:injectable-decorators
      */
     get<T>(name: string, ...args: any[]): Injectable<T> | undefined;
     /**
-     * @summary registers an injectable constructor
-     * @param {Injectable} constructor
-     * @param {any[]} args
-     *
-     * @method
+     * @description Adds a class or object to the injectable registry.
+     * @summary Registers an injectable constructor or instance with the registry, making it available for injection.
+     * @template T Type of the injectable object to register
+     * @param {Injectable<T>} constructor The class constructor or object instance to register
+     * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)
+     * @return {void}
+     * @memberOf module:injectable-decorators
      */
     register<T>(constructor: Injectable<T>, ...args: any[]): void;
     /**
-     * @summary Instantiates an Injectable
-     * @param {Record<string, any>} obj
-     * @param {any[]} args
-     * @return T
-     *
-     * @method
+     * @description Creates a new instance of an injectable class.
+     * @summary Instantiates an injectable class using its constructor and the provided arguments.
+     * @template T Type of the object to build
+     * @param {Record<string, any>} obj Object containing the name of the injectable to build
+     * @param {any[]} args Constructor arguments to pass when instantiating the injectable
+     * @return {T} The newly created instance
+     * @memberOf module:injectable-decorators
      */
     build<T>(obj: Record<string, any>, ...args: any[]): T;
 }
 /**
- * @summary Holds the vairous {@link Injectable}s
+ * @description Default implementation of the InjectablesRegistry interface.
+ * @summary Holds the various {@link Injectable}s in a cache and provides methods to register, retrieve, and build them.
+ * @template T Type parameter used in the class methods
+ *
  * @class InjectableRegistryImp
  * @implements InjectablesRegistry
+ *
+ * @memberOf module:injectable-decorators
+ *
+ * @example
+ * // Create a new registry
+ * const registry = new InjectableRegistryImp();
+ *
+ * // Register a class
+ * class MyService {
+ *   doSomething() {
+ *     return 'Hello World';
+ *   }
+ * }
+ * registry.register(MyService, 'MyService', true);
+ *
+ * // Get the instance
+ * const service = registry.get('MyService');
+ * service.doSomething(); // 'Hello World'
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Registry
+ *
+ *   Client->>Registry: register(MyService)
+ *   Registry->>Registry: Store in cache
+ *
+ *   Client->>Registry: get("MyService")
+ *   alt Instance exists and is singleton
+ *     Registry-->>Client: Return cached instance
+ *   else No instance or not singleton
+ *     Registry->>Registry: build(name)
+ *     Registry-->>Client: Return new instance
+ *   end
  */
 export declare class InjectableRegistryImp implements InjectablesRegistry {
     private cache;

package/lib/esm/registry.js

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