@decaf-ts/injectable-decorators 1.5.19 → 1.6.0

package/dist/injectable-decorators.cjs

@@ -0,0 +1,323 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('reflect-metadata')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'reflect-metadata'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["injectable-decorators"] = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * @summary Injectables Reflection keys
+     * @const InjectablesKeys
+     *
+     * @property {string} REFLECT Reflection injectables base key
+     * @property {string} INJECTABLE Reflection injectable key
+     * @property {string} INJECT Reflection inject key
+     *
+     * @memberOf injectable-decorators
+     */
+    const InjectablesKeys = {
+        REFLECT: "inject.db.",
+        INJECTABLE: "injectable",
+        INJECT: "inject",
+    };
+
+    /**
+     * @summary Holds the vairous {@link Injectable}s
+     * @class InjectableRegistryImp
+     * @implements InjectablesRegistry
+     */
+    class InjectableRegistryImp {
+        constructor() {
+            this.cache = {};
+        }
+        /**
+         * @inheritDoc
+         */
+        get(name, ...args) {
+            try {
+                const innerCache = this.cache[name];
+                const buildDef = { name: name };
+                if (!innerCache.singleton && !innerCache.instance)
+                    return this.build(buildDef, ...args);
+                return innerCache.instance || this.build(buildDef, ...args);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                return undefined;
+            }
+        }
+        /**
+         * @inheritDoc
+         */
+        register(obj, category = undefined, isSingleton = true, force = false) {
+            const castObj = obj;
+            const constructor = !castObj.name && castObj.constructor;
+            if (typeof castObj !== "function" && !constructor)
+                throw new Error(`Injectable registering failed. Missing Class name or constructor`);
+            const name = category ||
+                (constructor && constructor.name && constructor.name !== "Function"
+                    ? constructor.name
+                    : castObj.name);
+            if (!this.cache[name] || force)
+                this.cache[name] = {
+                    instance: constructor ? obj : undefined,
+                    constructor: !constructor ? obj : undefined,
+                    singleton: isSingleton,
+                };
+        }
+        /**
+         * @inheritDoc
+         */
+        build(defs, ...args) {
+            const { constructor, singleton } = this.cache[defs.name];
+            const instance = new constructor(...args);
+            this.cache[defs.name] = {
+                instance: instance,
+                constructor: constructor,
+                singleton: singleton,
+            };
+            return instance;
+        }
+    }
+
+    /**
+     * @summary Static class Holding the access to the injectables functions
+     *
+     * @class Injectables
+     * @static
+     */
+    class Injectables {
+        static { this.actingInjectablesRegistry = undefined; }
+        constructor() { }
+        /**
+         * @summary Retrieves the named {@link Injectable} from the registry
+         * @param {string} name
+         * @param {any[]} args
+         */
+        static get(name, ...args) {
+            return Injectables.getRegistry().get(name, ...args);
+        }
+        /**
+         * @summary registers an injectable constructor
+         * @param {Injectable} constructor
+         * @param {any[]} args
+         *
+         */
+        static register(constructor, ...args) {
+            return Injectables.getRegistry().register(constructor, ...args);
+        }
+        /**
+         * @summary Instantiates an Injectable
+         * @param {Record<string, any>} obj
+         * @param {any[]} args
+         * @return T
+         *
+         */
+        static build(obj, ...args) {
+            return Injectables.getRegistry().build(obj, ...args);
+        }
+        /**
+         * @summary Sets a new {@link InjectablesRegistry}
+         * @param {InjectablesRegistry} operationsRegistry the new implementation of Registry
+         */
+        static setRegistry(operationsRegistry) {
+            Injectables.actingInjectablesRegistry = operationsRegistry;
+        }
+        /**
+         * @summary Returns the current {@link InjectablesRegistry}
+         */
+        static getRegistry() {
+            if (!Injectables.actingInjectablesRegistry)
+                Injectables.actingInjectablesRegistry = new InjectableRegistryImp();
+            return Injectables.actingInjectablesRegistry;
+        }
+        static reset() {
+            Injectables.setRegistry(new InjectableRegistryImp());
+        }
+        static selectiveReset(match) {
+            const regexp = typeof match === "string" ? new RegExp(match) : match;
+            Injectables.actingInjectablesRegistry["cache"] = Object.entries(Injectables.actingInjectablesRegistry["cache"]).reduce((accum, [key, val]) => {
+                if (!key.match(regexp))
+                    accum[key] = val;
+                return accum;
+            }, {});
+        }
+    }
+
+    /**
+     * @summary holds the key for the design type
+     * @const TypeKey
+     * @memberOf  module:injectable-decorators
+     */
+    const TypeKey = "design:type";
+    /**
+     * @summary Retrieves the type from the decorators
+     * @param {any} model
+     * @param {string | symbol} propKey
+     * @return {string | undefined}
+     *
+     * @function geTypeFromDecorators
+     *
+     * @memberOf module:injectable-decorators
+     */
+    function getTypeFromDecorator(model, propKey) {
+        const typeDef = Reflect.getMetadata(TypeKey, model, propKey);
+        return typeDef.name !== "Function" ? typeDef.name : undefined;
+    }
+
+    /**
+     * @summary Return the reflection key for injectables
+     *
+     * @param {string} key
+     * @function getInjectKey
+     *
+     * @memberOf module:injectable-decorators
+     */
+    const getInjectKey = (key) => InjectablesKeys.REFLECT + key;
+    /**
+     * @summary Defines a class as an injectable
+     *
+     * @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
+     *
+     * @function injectable
+     *
+     * @memberOf module:injectable-decorators.Decorators
+     */
+    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,
+            });
+            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,
+        });
+        // 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
+     *
+     * Injected properties should be described like so:
+     * <pre>
+     *     class ClassName {
+     *         ...
+     *
+     *         @inject()
+     *         propertyName!: InjectableClass;
+     *
+     *         ...
+     *     }
+     * </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
+     *
+     * @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]
+     *
+     * @function inject
+     *
+     * @memberOf module:injectable-decorators.Decorators
+     */
+    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];
+                }
+            },
+        });
+    };
+
+    /**
+     * @summary Adds a simple Injectables implementation to create singleton instances of an object
+     * and easily inject it into other objects
+     *
+     * @module injectable-decorators
+     */
+    /**
+     * @summary functions that decorate classes or class properties
+     * @namespace Decorators
+     * @memberOf module:injectable-decorators
+     */
+    /**
+     * @summary Defined on library build. holds the library current version
+     * @const VERSION
+     * @memberOf module:injectable-decorators
+     */
+    const VERSION = "1.6.0";
+
+    exports.InjectableRegistryImp = InjectableRegistryImp;
+    exports.Injectables = Injectables;
+    exports.InjectablesKeys = InjectablesKeys;
+    exports.TypeKey = TypeKey;
+    exports.VERSION = VERSION;
+    exports.getTypeFromDecorator = getTypeFromDecorator;
+    exports.inject = inject;
+    exports.injectable = injectable;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"injectable-decorators.cjs","sources":["../src/constants.ts","../src/registry.ts","../src/Injectables.ts","../src/utils.ts","../src/decorators.ts","../src/index.ts"],"sourcesContent":["/**\n * @summary Injectables Reflection keys\n * @const InjectablesKeys\n *\n * @property {string} REFLECT Reflection injectables base key\n * @property {string} INJECTABLE Reflection injectable key\n * @property {string} INJECT Reflection inject key\n *\n * @memberOf injectable-decorators\n */\nexport const InjectablesKeys = {\n  REFLECT: \"inject.db.\",\n  INJECTABLE: \"injectable\",\n  INJECT: \"inject\",\n};\n","/**\n * @summary defines an Injectable type\n * @memberOf module:injectable-decorators\n */\nexport type Injectable<T> = { new (...args: any[]): T } | T;\n\n/**\n * @summary Interface for an injectable registry\n * @interface InjectableRegistry\n */\nexport interface InjectablesRegistry {\n  /**\n   * @summary retrieves an {@link Injectable}\n   * @param {string} name\n   * @param {any[]} args\n   * @return {Injectable | undefined}\n   *\n   * @method\n   */\n  get<T>(name: string, ...args: any[]): Injectable<T> | undefined;\n\n  /**\n   * @summary registers an injectable constructor\n   * @param {Injectable} constructor\n   * @param {any[]} args\n   *\n   * @method\n   */\n  register<T>(constructor: Injectable<T>, ...args: any[]): void;\n\n  /**\n   * @summary Instantiates an Injectable\n   * @param {Record<string, any>} obj\n   * @param {any[]} args\n   * @return T\n   *\n   * @method\n   */\n  build<T>(obj: Record<string, any>, ...args: any[]): T;\n}\n\n/**\n * @summary Holds the vairous {@link Injectable}s\n * @class InjectableRegistryImp\n * @implements InjectablesRegistry\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","import {\n  Injectable,\n  InjectableRegistryImp,\n  InjectablesRegistry,\n} from \"./registry\";\n\n/**\n * @summary Static class Holding the access to the injectables functions\n *\n * @class Injectables\n * @static\n */\nexport class Injectables {\n  private static actingInjectablesRegistry?: InjectablesRegistry = undefined;\n\n  private constructor() {}\n\n  /**\n   * @summary Retrieves the named {@link Injectable} from the registry\n   * @param {string} name\n   * @param {any[]} args\n   */\n  static get<T>(name: string, ...args: any[]): Injectable<T> | undefined {\n    return Injectables.getRegistry().get(name, ...args);\n  }\n\n  /**\n   * @summary registers an injectable constructor\n   * @param {Injectable} constructor\n   * @param {any[]} args\n   *\n   */\n  static register<T>(constructor: Injectable<T>, ...args: any[]): void {\n    return Injectables.getRegistry().register(constructor, ...args);\n  }\n\n  /**\n   * @summary Instantiates an Injectable\n   * @param {Record<string, any>} obj\n   * @param {any[]} args\n   * @return T\n   *\n   */\n  static build<T>(obj: Record<string, any>, ...args: any[]): T {\n    return Injectables.getRegistry().build(obj, ...args);\n  }\n\n  /**\n   * @summary Sets a new {@link InjectablesRegistry}\n   * @param {InjectablesRegistry} operationsRegistry the new implementation of Registry\n   */\n  static setRegistry(operationsRegistry: InjectablesRegistry) {\n    Injectables.actingInjectablesRegistry = operationsRegistry;\n  }\n  /**\n   * @summary Returns the current {@link InjectablesRegistry}\n   */\n  private static getRegistry() {\n    if (!Injectables.actingInjectablesRegistry)\n      Injectables.actingInjectablesRegistry = new InjectableRegistryImp();\n    return Injectables.actingInjectablesRegistry;\n  }\n\n  static reset() {\n    Injectables.setRegistry(new InjectableRegistryImp());\n  }\n\n  static selectiveReset(match: string | RegExp) {\n    const regexp = typeof match === \"string\" ? new RegExp(match) : match;\n    (Injectables.actingInjectablesRegistry as any)[\"cache\"] = Object.entries(\n      (Injectables.actingInjectablesRegistry as any)[\"cache\"]\n    ).reduce((accum: Record<string, any>, [key, val]) => {\n      if (!key.match(regexp)) accum[key] = val;\n      return accum;\n    }, {});\n  }\n}\n","import \"reflect-metadata\";\n\n/**\n * @summary holds the key for the design type\n * @const TypeKey\n * @memberOf  module:injectable-decorators\n */\nexport const TypeKey = \"design:type\";\n\n/**\n * @summary Retrieves the type from the decorators\n * @param {any} model\n * @param {string | symbol} propKey\n * @return {string | undefined}\n *\n * @function geTypeFromDecorators\n *\n * @memberOf module:injectable-decorators\n */\nexport function getTypeFromDecorator(\n  model: any,\n  propKey: string | symbol,\n): string | undefined {\n  const typeDef = Reflect.getMetadata(TypeKey, model, propKey);\n  return typeDef.name !== \"Function\" ? typeDef.name : undefined;\n}\n","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","/**\n * @summary Adds a simple Injectables implementation to create singleton instances of an object\n * and easily inject it into other objects\n *\n * @module injectable-decorators\n */\n\n/**\n * @summary functions that decorate classes or class properties\n * @namespace Decorators\n * @memberOf module:injectable-decorators\n */\n\nexport * from \"./constants\";\nexport * from \"./decorators\";\nexport * from \"./Injectables\";\nexport * from \"./registry\";\nexport * from \"./utils\";\n\n/**\n * @summary Defined on library build. holds the library current version\n * @const VERSION\n * @memberOf module:injectable-decorators\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}