@decaf-ts/injectable-decorators 1.5.15 → 1.6.0

package/README.md

@@ -6,18 +6,21 @@ Simple implementation of injectables
 ![Licence](https://img.shields.io/github/license/decaf-ts/injectable-decorators.svg?style=plastic)
 ![GitHub language count](https://img.shields.io/github/languages/count/decaf-ts/injectable-decorators?style=plastic)
 ![GitHub top language](https://img.shields.io/github/languages/top/decaf-ts/injectable-decorators?style=plastic)
-[![Tests](https://github.com/decaf-ts/injectable-decorators/actions/workflows/jest-test.yaml/badge.svg)](http://www.pdmfc.com)
-[![CodeQL](https://github.com/starnowski/posmulten/workflows/CodeQL/badge.svg)](https://github.com/decaf-ts/injectable-decorators/actions?query=workflow%3ACodeQL)
+
+[![Build & Test](https://github.com/decaf-ts/injectable-decorators/actions/workflows/nodejs-build-prod.yaml/badge.svg)](https://github.com/decaf-ts/injectable-decorators/actions/workflows/nodejs-build-prod.yaml)
+[![CodeQL](https://github.com/decaf-ts/injectable-decorators/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/decaf-ts/injectable-decorators/actions/workflows/codeql-analysis.yml)[![Snyk Analysis](https://github.com/decaf-ts/injectable-decorators/actions/workflows/snyk-analysis.yaml/badge.svg)](https://github.com/decaf-ts/injectable-decorators/actions/workflows/snyk-analysis.yaml)
+[![Pages builder](https://github.com/decaf-ts/injectable-decorators/actions/workflows/pages.yaml/badge.svg)](https://github.com/decaf-ts/injectable-decorators/actions/workflows/pages.yaml)
+[![.github/workflows/release-on-tag.yaml](https://github.com/decaf-ts/injectable-decorators/actions/workflows/release-on-tag.yaml/badge.svg?event=release)](https://github.com/decaf-ts/injectable-decorators/actions/workflows/release-on-tag.yaml)
 
 ![Open Issues](https://img.shields.io/github/issues/decaf-ts/injectable-decorators.svg)
 ![Closed Issues](https://img.shields.io/github/issues-closed/decaf-ts/injectable-decorators.svg)
 ![Pull Requests](https://img.shields.io/github/issues-pr-closed/decaf-ts/injectable-decorators.svg)
 ![Maintained](https://img.shields.io/badge/Maintained%3F-yes-green.svg)
 
-![Line Coverage](workdocs/coverage/badge-lines.svg)
-![Function Coverage](workdocs/coverage/badge-functions.svg)
-![Statement Coverage](workdocs/coverage/badge-statements.svg)
-![Branch Coverage](workdocs/coverage/badge-branches.svg)
+![Line Coverage](workdocs/reports/coverage/badge-lines.svg)
+![Function Coverage](workdocs/reports/coverage/badge-functions.svg)
+![Statement Coverage](workdocs/reports/coverage/badge-statements.svg)
+![Branch Coverage](workdocs/reports/coverage/badge-branches.svg)
 
 
 ![Forks](https://img.shields.io/github/forks/decaf-ts/injectable-decorators.svg)
@@ -27,108 +30,32 @@ Simple implementation of injectables
 ![Node Version](https://img.shields.io/badge/dynamic/json.svg?url=https%3A%2F%2Fraw.githubusercontent.com%2Fbadges%2Fshields%2Fmaster%2Fpackage.json&label=Node&query=$.engines.node&colorB=blue)
 ![NPM Version](https://img.shields.io/badge/dynamic/json.svg?url=https%3A%2F%2Fraw.githubusercontent.com%2Fbadges%2Fshields%2Fmaster%2Fpackage.json&label=NPM&query=$.engines.npm&colorB=purple)
 
-### Decorator based
+Documentation available [here](https://decaf-ts.github.io/injectable-decorators/)
+
+### Description
 
 Simple implementation of a Typescript decorator based injectable system.
-## Considerations
-
-#### Typescript Compilation options
-
-Even though all code is exported in both CommonJS and ESM format, and the default is ES2022
-in order to take advantage to all the latest Typescript and JS features,
-when importing  these libraries the following flag in `tsconfig.compilerOptions` is mandatory:
-```json
-{
-  "experimentalDecorators": true,
-  "emitDecoratorMetadata": true,
-  "useDefineForClassFields": false
-}
-```
+
+### How to Use
+
+- [Initial Setup](./tutorials/For%20Developers.md#_initial-setup_)
+- [Installation](./tutorials/For%20Developers.md#installation)
+
+
+
+
 ### Related
 
-[![Readme Card](https://github-readme-stats.vercel.app/api/pin/?username=decaf-ts&repo=decorator-validation)](https://github.com/decaf-ts/decorator-validation)
-[![Readme Card](https://github-readme-stats.vercel.app/api/pin/?username=decaf-ts&repo=db-decorators)](https://github.com/decaf-ts/db-decorators)
+[![Readme Card](https://github-readme-stats.vercel.app/api/pin/?username=decaf-ts&repo=ts-workspace)](https://github.com/decaf-ts/ts-workspace)
+
 ### Social
 
 [![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/decaf-ts/)
-### Scripts
-
-The following npm scripts are available for development:
-
-- `preinstall` - will run only on the first install to trigger the dep update. will self delete;
-- `do-install` - sets a `TOKEN` environment variable to the contents of `.token` and runs npm install (useful when you
-  have private dependencies);
-- `flash-forward` - updates all dependencies. Take care, This may not be desirable is some cases;
-- `reset` - updates all dependencies. Take care, This may not be desirable is some cases;
-- `build` - builds the code (via gulp `gulpfile.js`) in development mode (generates `lib` and `dist` folder);
-- `build:prod` - builds the code (via gulp `gulpfile.js`) in production mode (generates `lib` and `dist` folder);
-- `test` - runs unit tests;
-- `test:integration` - runs it tests;
-- `test:all` - runs all tests;
-- `lint` - runs es lint on the code folder;
-- `lint-fix` - tries to auto-fix the code folder;
-- `prepare-release` - defines the commands to run prior to a new tag (defaults to linting, building production code,
-  running tests and documentation generation);
-- `release` - triggers a new tag being pushed to master (via `./bin/tag_release.sh`);
-- `clean-publish` - cleans the package.json for publishing;
-- `coverage` - runs all test, calculates coverage and generates badges for readme;
-- `drawings` - compiles all DrawIO `*.drawio` files in the `workdocs/drawings` folder to png and moves them to
-  the `workdocs/resources` folder;
-- `uml` - compiles all PlantUML `*.puml` files in the `workdocs/uml` folder to png and moves them to
-  the `workdocs/resources` folder;
-- `docs` - compiles all the coverage, drawings, uml, jsdocs and md docs into a readable web page under `./docs`;
-
-### Repository Structure
-
-```
-injectable-decorators
-│
-│   .gitignore              <-- Defines files ignored to git
-│   .npmignore              <-- Defines files ignored by npm
-│   .nmprc                  <-- Defines the Npm registry for this package
-│   .eslintrc.cjs           <-- linting for the project
-│   .prettier.config.cjs    <-- Code style for the project
-│   .gitlab-ci.yml          <-- Gillab CI/CD file
-│   gulpfile.js             <-- Gulp build scripts. used for building na other features (eg docs)
-│   jest.config.ts          <-- Tests Configuration file
-│   mdCompile.json          <-- md Documentation generation configuration file
-│   jsdocs.json             <-- jsdoc Documentation generation configuration file
-│   Dockerfile              <-- minimal example of a node service Dockerfile
-│   LICENCE.md              <-- Licence disclamer
-│   package.json
-│   package-lock.json
-│   README.md               <-- Readme File dynamically compiled from 'workdocs' via the 'docs' npm script
-│   tsconfig.json           <-- Typescript config file. Is overriden in 'gulpfile.js' 
-│
-└───bin
-│   │   tag_release.sh      <-- Script to help with releases
-│   
-└───docs
-│   │   ...                 <-- Dinamically generated folder, containing the compiled documentation for this repository. generated via the 'docs' npm script
-│   
-└───src
-│   │   ...                 <-- Source code for this repository
-│   
-└───tests
-│   │───unit                <-- Unit tests
-│   └───integration         <-- Integration tests
-│   
-└───workdocs                <-- Folder with all pre-compiled documentation
-│   │───assets              <-- Documentation asset folder
-│   │───badges              <-- Auto generated coverage badges folder
-│   │───coverage            <-- Auto generated coverage results
-│   │───drawings            <-- DrawIO folder. Drawings (*.drawio) here will be processed to generate documentation (requires docker)
-│   │───uml                 <-- PlantUML folder. Diagrams (*.puml) here will be processed to generate documentation (requires docker)
-│   │───tutorials           <-- Tutorial folder
-│   │   ...                 <-- Categorized *.md files that are merged to generate the final readme (via md compile)
-│   │   Readme.md           <-- Entry point to the README.md   
-│  
-└───dist
-│   │   ...                 <-- Dinamically generated folder containing the bundles for distribution
-│
-└───lib
-    |   ...                 <-- Dinamically generated folder containing the compiled code
-```
+
+
+
+
+#### Languages
 
 ![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)
 ![JavaScript](https://img.shields.io/badge/JavaScript-F7DF1E?style=for-the-badge&logo=javascript&logoColor=black)
@@ -137,7 +64,7 @@ injectable-decorators
 
 ## Getting help
 
-If you have bug reports, questions or suggestions please [create a new issue](https://github.com/decaf-ts/decorator-validation/issues/new/choose).
+If you have bug reports, questions or suggestions please [create a new issue](https://github.com/decaf-ts/ts-workspace/issues/new/choose).
 
 ## Contributing
 
@@ -147,14 +74,12 @@ I am grateful for any contributions made to this project. Please read [this](./w
 
 The first and easiest way you can support it is by [Contributing](./workdocs/98-Contributing.md). Even just finding a typo in the documentation is important.
 
-Financial support is always welcome and helps keep the both me and the project alive and healthy.
+Financial support is always welcome and helps keep both me and the project alive and healthy.
 
 So if you can, if this project in any way. either by learning something or simply by helping you save precious time, please consider donating.
 
 ## License
 
-This project is released under the [MIT License](LICENSE.md).
-
-#### Disclaimer:
+This project is released under the [MIT License](./LICENSE.md).
 
-badges found [here](https://dev.to/envoy_/150-badges-for-github-pnk), [here](https://github.com/alexandresanlim/Badges4-README.md-Profile#-social-) and [here](https://github.com/Ileriayo/markdown-badges)
+By developers, for developers...

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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"}