@homer0/jimple 2.0.1 → 2.0.2

package/dist/esm/index.js

@@ -16,6 +16,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -51,6 +55,10 @@ var require_Jimple = __commonJS({
       static provider(register) {
         return { register };
       }
+      /**
+       * Create a Jimple Container.
+       * @param {Object?} [values] - An optional object whose keys and values will be associated in the container at initialization
+       */
       constructor(values) {
         this._items = {};
         this._instances = /* @__PURE__ */ new Map();
@@ -61,6 +69,13 @@ var require_Jimple = __commonJS({
           this.set(key, values[key]);
         }, this);
       }
+      /**
+       * Return the specified parameter or service. If the service is not built yet, this function will construct the service
+       * injecting all the dependencies needed in it's definition so the returned object is totally usable on the fly.
+       * @param {string} key - The key of the parameter or service to return
+       * @return {*} The object related to the service or the value of the parameter associated with the key informed
+       * @throws If the key does not exist
+       */
       get(key) {
         checkDefined(this, key);
         let item = this._items[key];
@@ -81,21 +96,53 @@ var require_Jimple = __commonJS({
         }
         return obj;
       }
+      /**
+       * Defines a new parameter or service.
+       * @param {string} key - The key of the parameter or service to be defined
+       * @param {*} value - The value of the parameter or a function that receives the container as parameter and constructs the service
+       */
       set(key, value) {
         this._items[key] = value;
       }
+      /**
+       * Returns if a service or parameter with the informed key is already defined in the container.
+       * @param {string} key - The key of the parameter or service to be checked.
+       * @return {boolean} If the key exists in the container or not
+       */
       has(key) {
         return this._items.hasOwnProperty(key);
       }
+      /**
+       * Defines a service as a factory, so the instances are not cached in the service and that function is always called
+       * @param {function(Jimple):*} fn - The function that constructs the service that is a factory
+       * @return {function(Jimple):*} The same function passed as parameter
+       */
       factory(fn) {
         return addFunctionTo(this._factories, fn);
       }
+      /**
+       * Defines a function as a parameter, so that function is not considered a service
+       * @param {*} fn - The function to not be considered a service
+       * @return {*} The same function passed as parameter
+       */
       protect(fn) {
         return addFunctionTo(this._protected, fn);
       }
+      /**
+       * Return all the keys registered in the container
+       * @returns {Array<string>}
+       */
       keys() {
         return Object.keys(this._items);
       }
+      /**
+       * Extends a service already registered in the container
+       * @param {string} key - The key of the service to be extended
+       * @param {function(*, Jimple):*} fn - The function that will be used to extend the service
+       * @throws If the key is not already defined
+       * @throws If the key saved in the container does not correspond to a service
+       * @throws If the function passed it not...well, a function
+       */
       extend(key, fn) {
         checkDefined(this, key);
         let originalItem = this._items[key];
@@ -109,9 +156,20 @@ var require_Jimple = __commonJS({
           this._factories.add(this._items[key]);
         }
       }
+      /**
+       * Uses an provider to extend the service, so it's easy to split the service and parameter definitions across the system
+       * @param {{register: function(Jimple)}} provider - The provider to be used to register services and parameters in this container
+       */
       register(provider2) {
         provider2.register(this);
       }
+      /**
+       * Returns the raw value of a service or parameter. So, in the case of a service, for example, the value returned is the
+       * function used to construct the service.
+       * @param {string} key - The key of the service or parameter to return.
+       * @throws If the key does not exist in the container
+       * @return {*} The raw value of the service or parameter
+       */
       raw(key) {
         checkDefined(this, key);
         return this._items[key];
@@ -127,6 +185,15 @@ var Jimple = import_jimple.default;
 
 // src/jimple/index.ts
 var Jimple2 = class extends Jimple {
+  /**
+   * This is a version of the `get` method that doesn't throw if the key doesn't exist. It
+   * will return `undefined` instead.
+   *
+   * @param key  The key of the parameter or service to return.
+   * @returns The object related to the service or the value of the parameter
+   *          associated with the given key.
+   * @template T  The type of the returned object.
+   */
   try(key) {
     if (!this.has(key)) {
       return void 0;
@@ -137,87 +204,183 @@ var Jimple2 = class extends Jimple {
 var jimple = (...args) => new Jimple2(...args);
 
 // src/factories/resourceFactory.ts
-var resourceFactory = () => (name, key, fn) => ({
-  [name]: true,
-  [key]: fn
-});
+var resourceFactory = () => (
+  /**
+   * Generates a new resource using the contraint defined in the factory.
+   *
+   * @param name  The name of the resource.
+   * @param key   The property key for the function.
+   * @param fn    The resource function.
+   * @returns An object with the `name` set to `true`, and the `fn` as the `key`.
+   * @template Name  The literal type of `name`, to be used in the return object.
+   * @template Key   The literal type of `key`, to be used in the return object.
+   * @template Fn    The type of `fn`, restricted by the factory constraint.
+   * @example
+   *
+   *   const myAction = factory('action', 'fn', (c) => {
+   *     c.set('foo', 'bar');
+   *   });
+   *
+   */
+  (name, key, fn) => ({
+    [name]: true,
+    [key]: fn
+  })
+);
 
 // src/factories/resourceCreatorFactory.ts
-var resourceCreatorFactory = () => (name, key, creatorFn) => {
-  const fnToProxy = (...args) => {
-    const actualResource = creatorFn(...args);
-    return resourceFactory()(name, key, actualResource);
-  };
-  const handler = {
-    name,
-    resource: null,
-    get(target, property) {
-      let result;
-      if (property === this.name) {
-        result = true;
-      } else if (property === key) {
-        if (this.resource === null) {
-          const newResource = creatorFn();
-          this.resource = newResource;
+var resourceCreatorFactory = () => (
+  /**
+   * Generates a new resource creator using the contraint defined in the factory.
+   *
+   * @param name       The name of the resource.
+   * @param key        The property key for the function.
+   * @param creatorFn  The curried function that returns the actual resource function.
+   * @returns A resource creator: an object that can be used as a resource, and as a
+   *          function that returns a resource.
+   * @template Name       The literal type of `name`, to be used in the return object.
+   * @template Key        The literal type of `key`, to be used in the return object.
+   * @template ResFn      The type of the resource function, the creator function needs
+   *                      to return. This is restricted by the factory constraint.
+   * @template CreatorFn  The literal type of `creatorFn`, to be used in the return
+   *                      object.
+   * @example
+   *
+   *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {
+   *     c.set(name, 'bar');
+   *   });
+   *
+   */
+  (name, key, creatorFn) => {
+    const fnToProxy = (...args) => {
+      const actualResource = creatorFn(...args);
+      return resourceFactory()(name, key, actualResource);
+    };
+    const handler = {
+      name,
+      resource: null,
+      get(target, property) {
+        let result;
+        if (property === this.name) {
+          result = true;
+        } else if (property === key) {
+          if (this.resource === null) {
+            const newResource = creatorFn();
+            this.resource = newResource;
+          }
+          result = this.resource;
+        } else {
+          const targetKey = property;
+          result = target[targetKey];
+        }
+        return result;
+      },
+      has(target, property) {
+        if (property === this.name || property === key) {
+          return true;
         }
-        result = this.resource;
-      } else {
         const targetKey = property;
-        result = target[targetKey];
+        return targetKey in target;
       }
-      return result;
-    },
-    has(target, property) {
-      if (property === this.name || property === key) {
-        return true;
-      }
-      const targetKey = property;
-      return targetKey in target;
-    }
-  };
-  return new Proxy(fnToProxy, handler);
-};
+    };
+    return new Proxy(fnToProxy, handler);
+  }
+);
 
 // src/factories/resourcesCollectionFactory.ts
-var resourcesCollectionFactory = () => (name, key, fn) => {
-  const collectionResourceFactory = resourceFactory();
-  return (items) => {
-    const invalidKeys = [name, key];
-    const itemsKeys = Object.keys(items);
-    const invalidKey = itemsKeys.some(
-      (itemKey) => invalidKeys.includes(String(itemKey))
-    );
-    if (invalidKey) {
-      throw new Error(
-        `No item on the collection can have the keys \`${name}\` nor \`${key}\``
+var resourcesCollectionFactory = () => (
+  /**
+   * Generates a function to create a collection of resources of an specified type. A
+   * collection is a dictionary of resources, and a resource itself, and when its
+   * "resource function" gets called, it calls the function of every resource (with the
+   * same args it recevied).
+   *
+   * @param name  The resource name the items in the collection must have.
+   * @param key   The key property the items in the collection must have.
+   * @param fn    A custom function to process the items in the collection, when the
+   *              collection function gets called.
+   * @returns A function that can be used to create a resources collection.
+   * @template Name      The literal type of `name`, to be used in the return object.
+   * @template Key       The literal type of `key`, to be used in the return object.
+   * @template ItemKey   To capture the name of the resources in the collection.
+   * @template Items     The kind of dictionary of resources the return function will
+   *                     expect.
+   * @template CustomFn  The type of `fn`, restricted by the factory constraint.
+   * @example
+   *
+   *   const myActions = factory('action', 'fn')({ myActionA, myActionB });
+   *
+   */
+  (name, key, fn) => {
+    const collectionResourceFactory = resourceFactory();
+    return (items) => {
+      const invalidKeys = [name, key];
+      const itemsKeys = Object.keys(items);
+      const invalidKey = itemsKeys.some(
+        (itemKey) => invalidKeys.includes(String(itemKey))
       );
-    }
-    const invalidItem = itemsKeys.find(
-      (itemKey) => typeof items[itemKey]?.[key] !== "function"
-    );
-    if (invalidItem) {
-      throw new Error(
-        `The item \`${String(
-          invalidItem
-        )}\` is invalid: it doesn't have a \`${key}\` function`
+      if (invalidKey) {
+        throw new Error(
+          `No item on the collection can have the keys \`${name}\` nor \`${key}\``
+        );
+      }
+      const invalidItem = itemsKeys.find(
+        (itemKey) => typeof items[itemKey]?.[key] !== "function"
       );
-    }
-    const useFn = fn ? (...args) => fn(items, ...args) : (...args) => {
-      itemsKeys.forEach((itemK) => {
-        const item = items[itemK];
-        const itemFn = item[key];
-        itemFn(...args);
-      });
-    };
-    return {
-      ...collectionResourceFactory(name, key, useFn),
-      ...items
+      if (invalidItem) {
+        throw new Error(
+          `The item \`${String(
+            invalidItem
+          )}\` is invalid: it doesn't have a \`${key}\` function`
+        );
+      }
+      const useFn = fn ? (...args) => fn(items, ...args) : (...args) => {
+        itemsKeys.forEach((itemK) => {
+          const item = items[itemK];
+          const itemFn = item[key];
+          itemFn(...args);
+        });
+      };
+      return {
+        ...collectionResourceFactory(name, key, useFn),
+        ...items
+      };
     };
-  };
-};
+  }
+);
 
 // src/helpers/injectHelper.ts
 var InjectHelper = class {
+  /**
+   * This method is meant to be used to validate the dependencies a service receives, and
+   * needs.
+   * It will check on the received dependencies, if a specific dependency exists, it will
+   * return it, otherwise, it will create a new instance.
+   *
+   * @param dependencies  The dependencies received by the implementation.
+   * @param key           The key of the dependency to validate.
+   * @param init          A function to create a dependency in case it doesn't exist in
+   *                      the dictionary.
+   * @returns An instance of the dependency.
+   * @template DepKey   The literal key of the dependency to validate.
+   * @template DepType  The type of the dependency, obtained from the dictionary sent
+   *                    to the constructor.
+   * @example
+   *
+   *   type Dependencies = {
+   *     dep: string;
+   *   };
+   *   const helper = new InjectHelper<Dependencies>();
+   *
+   *   type MyServiceOptions = {
+   *     inject?: Partial<Dependencies>;
+   *   };
+   *   const myService = ({ inject = {} }: MyServiceOptions) => {
+   *     const dep = helper.get(inject, 'dep', () => 'default');
+   *     console.log('dep:', dep);
+   *   };
+   *
+   */
   get(dependencies, key, init) {
     const existing = dependencies[key];
     if (typeof existing !== "undefined") {
@@ -225,6 +388,43 @@ var InjectHelper = class {
     }
     return init();
   }
+  /**
+   * This is meant to be used in a provider creator to resolve dependencies' names sent as
+   * options. For each dependency, the method will first check if a new name was
+   * specified, and try to get it with that name, otherwise, it will try to get it with
+   * the default name, and if it doesn't exist, it will just keep it as `undefined` and
+   * expect the service implements {@link InjectHelper.get} to ensure the dependency.
+   *
+   * @param dependencies  The dependencies needed by the service.
+   * @param container     A reference to the Jimple container.
+   * @param inject        A dictionary of dependencies names.
+   * @returns A dictionary of dependencies to send to the service.
+   * @template DepKey     The literal key of the dependencies to validate.
+   * @template Container  The type of the Jimple container.
+   * @example
+   *
+   *   type Dependencies = {
+   *     dep: string;
+   *   };
+   *   const helper = new InjectHelper<Dependencies>();
+   *
+   *   type MyProviderOptions = {
+   *     services?: {
+   *       [key in keyof Dependencies]?: string;
+   *     };
+   *   };
+   *
+   *   const myProvider = providerCreator(
+   *     ({ services = {} }: MyProviderOptions) =>
+   *       (container) => {
+   *         container.set('myService', () => {
+   *           const inject = helper.resolve(['dep'], container, services);
+   *           return myService({ inject });
+   *         });
+   *       },
+   *   );
+   *
+   */
   resolve(dependencies, container, inject) {
     const result = dependencies.reduce((acc, key) => {
       if (inject[key]) {

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../node_modules/jimple/src/Jimple.js","../../src/jimplemod/index.ts","../../src/jimple/index.ts","../../src/factories/resourceFactory.ts","../../src/factories/resourceCreatorFactory.ts","../../src/factories/resourcesCollectionFactory.ts","../../src/helpers/injectHelper.ts","../../src/helpers/provider.ts","../../src/helpers/providerCreator.ts","../../src/helpers/providers.ts"],"sourcesContent":["\"use strict\";\n\nfunction assert(ok, message) {\n    if (!ok) {\n        throw new Error(message)\n    }\n}\n\nfunction isFunction(fn) {\n    return Object.prototype.toString.call(fn) === \"[object Function]\" && fn.constructor.name === \"Function\";\n}\n\nfunction isPlainObject(value) {\n    if (Object.prototype.toString.call(value) !== '[object Object]') {\n        return false;\n    }\n    let prototype = Object.getPrototypeOf(value);\n    return prototype === null || prototype === Object.prototype;\n}\n\nfunction checkDefined(container, key) {\n    assert(container.has(key), `Identifier \"${key}\" is not defined.`);\n}\n\nfunction addFunctionTo(set, fn) {\n    assert(isFunction(fn), \"Service definition is not a Closure or invokable object\");\n    set.add(fn);\n    return fn;\n}\n\n/**\n * The Jimple Container class\n *\n * @public\n */\nclass Jimple {\n    static provider(register) {\n      return ({ register });\n    }\n    /**\n     * Create a Jimple Container.\n     * @param {Object?} [values] - An optional object whose keys and values will be associated in the container at initialization\n     */\n    constructor(values) {\n        this._items = {};\n        this._instances = new Map();\n        this._factories = new Set();\n        this._protected = new Set();\n        values = isPlainObject(values) ? values : {};\n        Object.keys(values).forEach(function(key) {\n            this.set(key, values[key]);\n        }, this);\n    }\n    /**\n     * Return the specified parameter or service. If the service is not built yet, this function will construct the service\n     * injecting all the dependencies needed in it's definition so the returned object is totally usable on the fly.\n     * @param {string} key - The key of the parameter or service to return\n     * @return {*} The object related to the service or the value of the parameter associated with the key informed\n     * @throws If the key does not exist\n     */\n    get(key) {\n        checkDefined(this, key);\n        let item = this._items[key];\n        let obj;\n        if (isFunction(item)) {\n            if (this._protected.has(item)) {\n                obj = item;\n            } else if (this._instances.has(item)) {\n                obj = this._instances.get(item);\n            } else {\n                obj = item(this);\n                if (!this._factories.has(item)) {\n                    this._instances.set(item, obj);\n                }\n            }\n        } else {\n            obj = item;\n        }\n        return obj;\n    }\n    /**\n     * Defines a new parameter or service.\n     * @param {string} key - The key of the parameter or service to be defined\n     * @param {*} value - The value of the parameter or a function that receives the container as parameter and constructs the service\n     */\n    set(key, value) {\n        this._items[key] = value;\n    }\n\n    /**\n     * Returns if a service or parameter with the informed key is already defined in the container.\n     * @param {string} key - The key of the parameter or service to be checked.\n     * @return {boolean} If the key exists in the container or not\n     */\n    has(key) {\n        return this._items.hasOwnProperty(key);\n    }\n\n    /**\n     * Defines a service as a factory, so the instances are not cached in the service and that function is always called\n     * @param {function(Jimple):*} fn - The function that constructs the service that is a factory\n     * @return {function(Jimple):*} The same function passed as parameter\n     */\n    factory(fn) {\n        return addFunctionTo(this._factories, fn);\n    }\n\n    /**\n     * Defines a function as a parameter, so that function is not considered a service\n     * @param {*} fn - The function to not be considered a service\n     * @return {*} The same function passed as parameter\n     */\n    protect(fn) {\n        return addFunctionTo(this._protected, fn);\n    }\n\n    /**\n     * Return all the keys registered in the container\n     * @returns {Array<string>}\n     */\n    keys() {\n        return Object.keys(this._items);\n    }\n\n    /**\n     * Extends a service already registered in the container\n     * @param {string} key - The key of the service to be extended\n     * @param {function(*, Jimple):*} fn - The function that will be used to extend the service\n     * @throws If the key is not already defined\n     * @throws If the key saved in the container does not correspond to a service\n     * @throws If the function passed it not...well, a function\n     */\n    extend(key, fn) {\n        checkDefined(this, key);\n        let originalItem = this._items[key];\n        assert(isFunction(originalItem) && this._protected.has(originalItem) === false, `Identifier '${key}' does not contain a service definition`);\n        assert(isFunction(fn), `The 'new' service definition for '${key}' is not a invokable object.`);\n        this._items[key] = function(app) {\n            return fn(originalItem(app), app);\n        }\n        if (this._factories.has(originalItem)) {\n            this._factories.delete(originalItem);\n            this._factories.add(this._items[key]);\n        }\n    }\n\n    /**\n     * Uses an provider to extend the service, so it's easy to split the service and parameter definitions across the system\n     * @param {{register: function(Jimple)}} provider - The provider to be used to register services and parameters in this container\n     */\n    register(provider) {\n        provider.register(this);\n    }\n\n    /**\n     * Returns the raw value of a service or parameter. So, in the case of a service, for example, the value returned is the\n     * function used to construct the service.\n     * @param {string} key - The key of the service or parameter to return.\n     * @throws If the key does not exist in the container\n     * @return {*} The raw value of the service or parameter\n     */\n    raw(key) {\n        checkDefined(this, key);\n        return this._items[key];\n    }\n}\n\nmodule.exports = Jimple;\n","// @ts-expect-error - the idea is to have `any` and assert on export.\nimport JimpleOriginal from 'jimple';\nimport { Container as JimpleContainer } from './jimple.type';\n\nconst Jimple = JimpleOriginal as typeof JimpleContainer;\n\nexport { Jimple };\nexport type { JimpleContainer };\n","import { Jimple as JimpleMod } from '../jimplemod';\n\nexport class Jimple extends JimpleMod {\n  /**\n   * This is a version of the `get` method that doesn't throw if the key doesn't exist. It\n   * will return `undefined` instead.\n   *\n   * @param key  The key of the parameter or service to return.\n   * @returns The object related to the service or the value of the parameter\n   *          associated with the given key.\n   * @template T  The type of the returned object.\n   */\n  try<T = unknown>(key: string): T | undefined {\n    if (!this.has(key)) {\n      return undefined;\n    }\n\n    return this.get<T>(key);\n  }\n}\n/**\n * Shorthand for `new Jimple()`.\n *\n * @param args  The same parameters as the {@link Jimple} constructor.\n * @returns A new instance of {@link Jimple}.\n */\nexport const jimple = (...args: ConstructorParameters<typeof Jimple>): Jimple =>\n  new Jimple(...args);\n","import type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to create resources of an specified type. This function itself\n * doesn't have logic, but it's just in charge of creating the constraint for the resource\n * function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create a resource with a specified type of\n *          function.\n * @template ResourceFn  The type of function the resource needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (c) => {\n *     c.set('foo', 'bar');\n *   });\n *\n */\nexport const resourceFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource using the contraint defined in the factory.\n   *\n   * @param name  The name of the resource.\n   * @param key   The property key for the function.\n   * @param fn    The resource function.\n   * @returns An object with the `name` set to `true`, and the `fn` as the `key`.\n   * @template Name  The literal type of `name`, to be used in the return object.\n   * @template Key   The literal type of `key`, to be used in the return object.\n   * @template Fn    The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (c) => {\n   *     c.set('foo', 'bar');\n   *   });\n   *\n   */\n  <Name extends string, Key extends string, Fn extends ResourceFn>(\n    name: Name,\n    key: Key,\n    fn: Fn,\n  ): Resource<Name, Key, Fn> =>\n    ({\n      [name]: true,\n      [key]: fn,\n    } as Resource<Name, Key, Fn>);\n","import { resourceFactory } from './resourceFactory';\nimport type {\n  GenericFn,\n  GenericCurriedFn,\n  ResourceCreator,\n  ResourceCreatorCurriedFn,\n  ResourceCreatorHandler,\n} from './factories.types';\n/**\n * Generates a function to create resource creators of an specified type. This function\n * itself doesn't have logic, but it's just in charge of creating the constraint for the\n * resource creator function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create \"resource creators\".\n * @template ResourceFn  The type of function the resource creator needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceCreatorFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n *     c.set(name, 'bar');\n *   });\n *\n */\nexport const resourceCreatorFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource creator using the contraint defined in the factory.\n   *\n   * @param name       The name of the resource.\n   * @param key        The property key for the function.\n   * @param creatorFn  The curried function that returns the actual resource function.\n   * @returns A resource creator: an object that can be used as a resource, and as a\n   *          function that returns a resource.\n   * @template Name       The literal type of `name`, to be used in the return object.\n   * @template Key        The literal type of `key`, to be used in the return object.\n   * @template ResFn      The type of the resource function, the creator function needs\n   *                      to return. This is restricted by the factory constraint.\n   * @template CreatorFn  The literal type of `creatorFn`, to be used in the return\n   *                      object.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n   *     c.set(name, 'bar');\n   *   });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ResFn extends ResourceFn,\n    CreatorFn extends GenericCurriedFn<ResFn>,\n  >(\n    name: Name,\n    key: Key,\n    creatorFn: CreatorFn,\n  ): ResourceCreator<Name, Key, CreatorFn, ResourceFn> => {\n    const fnToProxy: ResourceCreatorCurriedFn<Name, Key, CreatorFn> = (...args) => {\n      const actualResource = creatorFn(...args) as ReturnType<CreatorFn>;\n      return resourceFactory<ResFn>()(name, key, actualResource);\n    };\n\n    const handler: ResourceCreatorHandler<Name, Key, CreatorFn> = {\n      name,\n      resource: null,\n      get(target, property) {\n        let result;\n        if (property === this.name) {\n          result = true;\n        } else if (property === key) {\n          if (this.resource === null) {\n            const newResource = creatorFn() as ReturnType<CreatorFn>;\n            this.resource = newResource;\n          }\n          result = this.resource;\n        } else {\n          const targetKey = property as keyof typeof target;\n          result = target[targetKey];\n        }\n\n        return result;\n      },\n      has(target, property) {\n        if (property === this.name || property === key) {\n          return true;\n        }\n\n        const targetKey = property as keyof typeof target;\n        return targetKey in target;\n      },\n    };\n\n    return new Proxy(fnToProxy, handler) as unknown as ResourceCreator<\n      Name,\n      Key,\n      CreatorFn,\n      ResourceFn\n    >;\n  };\n","import { resourceFactory } from './resourceFactory';\nimport type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to configure a collection of resources of an specified type. This\n * function itself doesn't have logic, but it's just in charge of creating the constraint\n * for the resource name and function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to configure a collection of resources.\n * @template ResourceName  The literal type of the name the resources needs to have.\n * @template ResourceFn    The type of function the resources needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourcesCollectionFactory<'action', ActionFn>();\n *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n *\n */\nexport const resourcesCollectionFactory =\n  <ResourceName extends string, ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a function to create a collection of resources of an specified type. A\n   * collection is a dictionary of resources, and a resource itself, and when its\n   * \"resource function\" gets called, it calls the function of every resource (with the\n   * same args it recevied).\n   *\n   * @param name  The resource name the items in the collection must have.\n   * @param key   The key property the items in the collection must have.\n   * @param fn    A custom function to process the items in the collection, when the\n   *              collection function gets called.\n   * @returns A function that can be used to create a resources collection.\n   * @template Name      The literal type of `name`, to be used in the return object.\n   * @template Key       The literal type of `key`, to be used in the return object.\n   * @template ItemKey   To capture the name of the resources in the collection.\n   * @template Items     The kind of dictionary of resources the return function will\n   *                     expect.\n   * @template CustomFn  The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ItemKey extends string,\n    Items extends Record<ItemKey, Resource<ResourceName, Key, ResourceFn>>,\n    CustomFn extends (items: Items, ...rest: Parameters<ResourceFn>) => void,\n  >(\n    name: Name,\n    key: Key,\n    fn?: CustomFn,\n  ) => {\n    const collectionResourceFactory = resourceFactory<ResourceFn>();\n    /**\n     * The actual function that recevies the items and creates the collection.\n     *\n     * @param items  A dictionary of resources for the collection.\n     * @returns A dictionary of the resources, that it's also a resource.\n     * @template ItemsParam  The literal type of `items`, to be used in the return\n     *                       object.\n     * @throws If the dictionary contains the resource name or function key as keys.\n     * @throws If one of the items doesn't have the resource function.\n     */\n    return <ItemsParam>(\n      items: ItemsParam & Items,\n    ): typeof items & Resource<Name, Key, ResourceFn> => {\n      const invalidKeys: string[] = [name, key];\n      const itemsKeys = Object.keys(items) as Array<keyof Items>;\n\n      const invalidKey = itemsKeys.some((itemKey) =>\n        invalidKeys.includes(String(itemKey)),\n      );\n      if (invalidKey) {\n        throw new Error(\n          `No item on the collection can have the keys \\`${name}\\` nor \\`${key}\\``,\n        );\n      }\n\n      const invalidItem = itemsKeys.find(\n        (itemKey) => typeof items[itemKey]?.[key] !== 'function',\n      );\n      if (invalidItem) {\n        throw new Error(\n          `The item \\`${String(\n            invalidItem,\n          )}\\` is invalid: it doesn't have a \\`${key}\\` function`,\n        );\n      }\n\n      const useFn = fn\n        ? (...args: Parameters<ResourceFn>) => fn(items, ...args)\n        : (...args: Parameters<ResourceFn>) => {\n            itemsKeys.forEach((itemK) => {\n              const item = items[itemK]!;\n              const itemFn = item[key];\n              itemFn(...args);\n            });\n          };\n\n      return {\n        ...collectionResourceFactory(name, key, useFn as ResourceFn),\n        ...items,\n      };\n    };\n  };\n","import type { Jimple } from '../jimple';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- They are dynamically extended.\ntype GenericDict = Record<any, any>;\n/**\n * A helper that reusable services can use to resolve dependencies in constructors and/or\n * providers.\n *\n * @template InjectDictionary  A dictionary of the dependencies and their types.\n * @template InjectKey         The literal type of the dictionary types.\n */\nexport class InjectHelper<\n  InjectDictionary extends GenericDict,\n  InjectKey = keyof InjectDictionary,\n> {\n  /**\n   * This method is meant to be used to validate the dependencies a service receives, and\n   * needs.\n   * It will check on the received dependencies, if a specific dependency exists, it will\n   * return it, otherwise, it will create a new instance.\n   *\n   * @param dependencies  The dependencies received by the implementation.\n   * @param key           The key of the dependency to validate.\n   * @param init          A function to create a dependency in case it doesn't exist in\n   *                      the dictionary.\n   * @returns An instance of the dependency.\n   * @template DepKey   The literal key of the dependency to validate.\n   * @template DepType  The type of the dependency, obtained from the dictionary sent\n   *                    to the constructor.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyServiceOptions = {\n   *     inject?: Partial<Dependencies>;\n   *   };\n   *   const myService = ({ inject = {} }: MyServiceOptions) => {\n   *     const dep = helper.get(inject, 'dep', () => 'default');\n   *     console.log('dep:', dep);\n   *   };\n   *\n   */\n  get<DepKey extends InjectKey, DepType = InjectDictionary[DepKey]>(\n    dependencies: Partial<InjectDictionary>,\n    key: InjectKey,\n    init: () => DepType,\n  ): DepType {\n    const existing = dependencies[key];\n    if (typeof existing !== 'undefined') {\n      return existing!;\n    }\n\n    return init();\n  }\n  /**\n   * This is meant to be used in a provider creator to resolve dependencies' names sent as\n   * options. For each dependency, the method will first check if a new name was\n   * specified, and try to get it with that name, otherwise, it will try to get it with\n   * the default name, and if it doesn't exist, it will just keep it as `undefined` and\n   * expect the service implements {@link InjectHelper.get} to ensure the dependency.\n   *\n   * @param dependencies  The dependencies needed by the service.\n   * @param container     A reference to the Jimple container.\n   * @param inject        A dictionary of dependencies names.\n   * @returns A dictionary of dependencies to send to the service.\n   * @template DepKey     The literal key of the dependencies to validate.\n   * @template Container  The type of the Jimple container.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyProviderOptions = {\n   *     services?: {\n   *       [key in keyof Dependencies]?: string;\n   *     };\n   *   };\n   *\n   *   const myProvider = providerCreator(\n   *     ({ services = {} }: MyProviderOptions) =>\n   *       (container) => {\n   *         container.set('myService', () => {\n   *           const inject = helper.resolve(['dep'], container, services);\n   *           return myService({ inject });\n   *         });\n   *       },\n   *   );\n   *\n   */\n  resolve<DepKey extends InjectKey, Container extends Jimple>(\n    dependencies: DepKey[],\n    container: Container,\n    inject: Partial<Record<keyof InjectDictionary, string>>,\n  ): Partial<InjectDictionary> {\n    const result = dependencies.reduce<Partial<InjectDictionary>>((acc, key) => {\n      if (inject[key]) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(inject[key]!);\n        return acc;\n      }\n\n      const keyStr = key as unknown as string;\n      if (container.has(keyStr)) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(keyStr);\n        return acc;\n      }\n\n      return acc;\n    }, {});\n\n    return result;\n  }\n}\n/**\n * Shorthand for `new InjectHelper()`.\n *\n * @returns A new instance of {@link InjectHelper}.\n */\nexport const injectHelper = <InjectDictionary extends GenericDict>() =>\n  new InjectHelper<InjectDictionary>();\n","import type { Jimple } from '../jimple';\nimport { resourceFactory } from '../factories';\n\nexport type ProviderName = 'provider';\nexport type ProviderKey = 'register';\n/**\n * The function the container will call when the provider is registered.\n *\n * @param container  A reference for container where the provider is being registered.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport type ProviderRegisterFn<ContainerType extends Jimple = Jimple> = (\n  container: ContainerType,\n) => void;\n/**\n * Generates a function to create providers for a specific type of container.\n *\n * @returns A function to create providers.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProvider = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourceFactory<RegisterFn>();\n  return (register: RegisterFn) => factory('provider', 'register', register);\n};\n/**\n * Creates a resource to be registered in a Jimple container.\n *\n * @example\n *\n *   export const myService = provider((c) => {\n *     c.set('myService', () => new MyService());\n *   });\n *\n */\nexport const provider = createProvider();\n/**\n * A resource that can be registered in a Jimple container.\n */\nexport type Provider = ReturnType<typeof provider>;\n","import type { Jimple } from '../jimple';\nimport { resourceCreatorFactory, type GenericCurriedFn } from '../factories';\nimport type { ProviderRegisterFn } from './provider';\n/**\n * Generates a function to create \"provider creators\" for a specific type of container.\n *\n * @returns A function to generate provider creators.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviderCreator = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  type ProviderCreatorFn = GenericCurriedFn<RegisterFn>;\n  const factory = resourceCreatorFactory<RegisterFn>();\n  return <CreatorFn extends ProviderCreatorFn>(creator: CreatorFn) =>\n    factory('provider', 'register', creator);\n};\n/**\n * Generates a \"provider creator\": a provider that can also be called as a function in\n * order to create a configured provider.\n *\n * @example\n *\n *   export const myService = providerCreator((options: Opts = {}) => (c) => {\n *     c.set('myService', () => new MyService(options));\n *   });\n *\n */\nexport const providerCreator = createProviderCreator();\n/**\n * A function that returns a provider registration function.\n */\nexport type ProviderCreatorFn = Parameters<typeof providerCreator>[0];\n","import type { Jimple } from '../jimple';\nimport { resourcesCollectionFactory } from '../factories';\nimport type { ProviderRegisterFn, ProviderName } from './provider';\n/**\n * Generates a function to create a providers collection for a specific type of container.\n *\n * @returns A function to create providers collections.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviders = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourcesCollectionFactory<ProviderName, RegisterFn>();\n  return factory('provider', 'register');\n};\n/**\n * Generates a collection of providers. A collection is a dictionary of providers that can\n * also be used as a provider, and when it gets registered, it will register all of the\n * providers in the collection.\n *\n * @param items  A dictionary of providers.\n * @example\n *\n * <caption>Assuming we already have two service providers...</caption>\n *\n *   export const services = providers({\n *     myServiceProvider,\n *     myOtherServiceProvider,\n *   });\n *\n */\nexport const providers = createProviders();\n"],"mappings":"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","names":["Jimple","provider","JimpleOriginal","Jimple"]}
+{"version":3,"sources":["../../../../../node_modules/jimple/src/Jimple.js","../../src/jimplemod/index.ts","../../src/jimple/index.ts","../../src/factories/resourceFactory.ts","../../src/factories/resourceCreatorFactory.ts","../../src/factories/resourcesCollectionFactory.ts","../../src/helpers/injectHelper.ts","../../src/helpers/provider.ts","../../src/helpers/providerCreator.ts","../../src/helpers/providers.ts"],"sourcesContent":["\"use strict\";\n\nfunction assert(ok, message) {\n    if (!ok) {\n        throw new Error(message)\n    }\n}\n\nfunction isFunction(fn) {\n    return Object.prototype.toString.call(fn) === \"[object Function]\" && fn.constructor.name === \"Function\";\n}\n\nfunction isPlainObject(value) {\n    if (Object.prototype.toString.call(value) !== '[object Object]') {\n        return false;\n    }\n    let prototype = Object.getPrototypeOf(value);\n    return prototype === null || prototype === Object.prototype;\n}\n\nfunction checkDefined(container, key) {\n    assert(container.has(key), `Identifier \"${key}\" is not defined.`);\n}\n\nfunction addFunctionTo(set, fn) {\n    assert(isFunction(fn), \"Service definition is not a Closure or invokable object\");\n    set.add(fn);\n    return fn;\n}\n\n/**\n * The Jimple Container class\n *\n * @public\n */\nclass Jimple {\n    static provider(register) {\n      return ({ register });\n    }\n    /**\n     * Create a Jimple Container.\n     * @param {Object?} [values] - An optional object whose keys and values will be associated in the container at initialization\n     */\n    constructor(values) {\n        this._items = {};\n        this._instances = new Map();\n        this._factories = new Set();\n        this._protected = new Set();\n        values = isPlainObject(values) ? values : {};\n        Object.keys(values).forEach(function(key) {\n            this.set(key, values[key]);\n        }, this);\n    }\n    /**\n     * Return the specified parameter or service. If the service is not built yet, this function will construct the service\n     * injecting all the dependencies needed in it's definition so the returned object is totally usable on the fly.\n     * @param {string} key - The key of the parameter or service to return\n     * @return {*} The object related to the service or the value of the parameter associated with the key informed\n     * @throws If the key does not exist\n     */\n    get(key) {\n        checkDefined(this, key);\n        let item = this._items[key];\n        let obj;\n        if (isFunction(item)) {\n            if (this._protected.has(item)) {\n                obj = item;\n            } else if (this._instances.has(item)) {\n                obj = this._instances.get(item);\n            } else {\n                obj = item(this);\n                if (!this._factories.has(item)) {\n                    this._instances.set(item, obj);\n                }\n            }\n        } else {\n            obj = item;\n        }\n        return obj;\n    }\n    /**\n     * Defines a new parameter or service.\n     * @param {string} key - The key of the parameter or service to be defined\n     * @param {*} value - The value of the parameter or a function that receives the container as parameter and constructs the service\n     */\n    set(key, value) {\n        this._items[key] = value;\n    }\n\n    /**\n     * Returns if a service or parameter with the informed key is already defined in the container.\n     * @param {string} key - The key of the parameter or service to be checked.\n     * @return {boolean} If the key exists in the container or not\n     */\n    has(key) {\n        return this._items.hasOwnProperty(key);\n    }\n\n    /**\n     * Defines a service as a factory, so the instances are not cached in the service and that function is always called\n     * @param {function(Jimple):*} fn - The function that constructs the service that is a factory\n     * @return {function(Jimple):*} The same function passed as parameter\n     */\n    factory(fn) {\n        return addFunctionTo(this._factories, fn);\n    }\n\n    /**\n     * Defines a function as a parameter, so that function is not considered a service\n     * @param {*} fn - The function to not be considered a service\n     * @return {*} The same function passed as parameter\n     */\n    protect(fn) {\n        return addFunctionTo(this._protected, fn);\n    }\n\n    /**\n     * Return all the keys registered in the container\n     * @returns {Array<string>}\n     */\n    keys() {\n        return Object.keys(this._items);\n    }\n\n    /**\n     * Extends a service already registered in the container\n     * @param {string} key - The key of the service to be extended\n     * @param {function(*, Jimple):*} fn - The function that will be used to extend the service\n     * @throws If the key is not already defined\n     * @throws If the key saved in the container does not correspond to a service\n     * @throws If the function passed it not...well, a function\n     */\n    extend(key, fn) {\n        checkDefined(this, key);\n        let originalItem = this._items[key];\n        assert(isFunction(originalItem) && this._protected.has(originalItem) === false, `Identifier '${key}' does not contain a service definition`);\n        assert(isFunction(fn), `The 'new' service definition for '${key}' is not a invokable object.`);\n        this._items[key] = function(app) {\n            return fn(originalItem(app), app);\n        }\n        if (this._factories.has(originalItem)) {\n            this._factories.delete(originalItem);\n            this._factories.add(this._items[key]);\n        }\n    }\n\n    /**\n     * Uses an provider to extend the service, so it's easy to split the service and parameter definitions across the system\n     * @param {{register: function(Jimple)}} provider - The provider to be used to register services and parameters in this container\n     */\n    register(provider) {\n        provider.register(this);\n    }\n\n    /**\n     * Returns the raw value of a service or parameter. So, in the case of a service, for example, the value returned is the\n     * function used to construct the service.\n     * @param {string} key - The key of the service or parameter to return.\n     * @throws If the key does not exist in the container\n     * @return {*} The raw value of the service or parameter\n     */\n    raw(key) {\n        checkDefined(this, key);\n        return this._items[key];\n    }\n}\n\nmodule.exports = Jimple;\n","// @ts-expect-error - the idea is to have `any` and assert on export.\nimport JimpleOriginal from 'jimple';\nimport { Container as JimpleContainer } from './jimple.type';\n\nconst Jimple = JimpleOriginal as typeof JimpleContainer;\n\nexport { Jimple };\nexport type { JimpleContainer };\n","import { Jimple as JimpleMod } from '../jimplemod';\n\nexport class Jimple extends JimpleMod {\n  /**\n   * This is a version of the `get` method that doesn't throw if the key doesn't exist. It\n   * will return `undefined` instead.\n   *\n   * @param key  The key of the parameter or service to return.\n   * @returns The object related to the service or the value of the parameter\n   *          associated with the given key.\n   * @template T  The type of the returned object.\n   */\n  try<T = unknown>(key: string): T | undefined {\n    if (!this.has(key)) {\n      return undefined;\n    }\n\n    return this.get<T>(key);\n  }\n}\n/**\n * Shorthand for `new Jimple()`.\n *\n * @param args  The same parameters as the {@link Jimple} constructor.\n * @returns A new instance of {@link Jimple}.\n */\nexport const jimple = (...args: ConstructorParameters<typeof Jimple>): Jimple =>\n  new Jimple(...args);\n","import type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to create resources of an specified type. This function itself\n * doesn't have logic, but it's just in charge of creating the constraint for the resource\n * function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create a resource with a specified type of\n *          function.\n * @template ResourceFn  The type of function the resource needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (c) => {\n *     c.set('foo', 'bar');\n *   });\n *\n */\nexport const resourceFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource using the contraint defined in the factory.\n   *\n   * @param name  The name of the resource.\n   * @param key   The property key for the function.\n   * @param fn    The resource function.\n   * @returns An object with the `name` set to `true`, and the `fn` as the `key`.\n   * @template Name  The literal type of `name`, to be used in the return object.\n   * @template Key   The literal type of `key`, to be used in the return object.\n   * @template Fn    The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (c) => {\n   *     c.set('foo', 'bar');\n   *   });\n   *\n   */\n  <Name extends string, Key extends string, Fn extends ResourceFn>(\n    name: Name,\n    key: Key,\n    fn: Fn,\n  ): Resource<Name, Key, Fn> =>\n    ({\n      [name]: true,\n      [key]: fn,\n    } as Resource<Name, Key, Fn>);\n","import { resourceFactory } from './resourceFactory';\nimport type {\n  GenericFn,\n  GenericCurriedFn,\n  ResourceCreator,\n  ResourceCreatorCurriedFn,\n  ResourceCreatorHandler,\n} from './factories.types';\n/**\n * Generates a function to create resource creators of an specified type. This function\n * itself doesn't have logic, but it's just in charge of creating the constraint for the\n * resource creator function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create \"resource creators\".\n * @template ResourceFn  The type of function the resource creator needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceCreatorFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n *     c.set(name, 'bar');\n *   });\n *\n */\nexport const resourceCreatorFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource creator using the contraint defined in the factory.\n   *\n   * @param name       The name of the resource.\n   * @param key        The property key for the function.\n   * @param creatorFn  The curried function that returns the actual resource function.\n   * @returns A resource creator: an object that can be used as a resource, and as a\n   *          function that returns a resource.\n   * @template Name       The literal type of `name`, to be used in the return object.\n   * @template Key        The literal type of `key`, to be used in the return object.\n   * @template ResFn      The type of the resource function, the creator function needs\n   *                      to return. This is restricted by the factory constraint.\n   * @template CreatorFn  The literal type of `creatorFn`, to be used in the return\n   *                      object.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n   *     c.set(name, 'bar');\n   *   });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ResFn extends ResourceFn,\n    CreatorFn extends GenericCurriedFn<ResFn>,\n  >(\n    name: Name,\n    key: Key,\n    creatorFn: CreatorFn,\n  ): ResourceCreator<Name, Key, CreatorFn, ResourceFn> => {\n    const fnToProxy: ResourceCreatorCurriedFn<Name, Key, CreatorFn> = (...args) => {\n      const actualResource = creatorFn(...args) as ReturnType<CreatorFn>;\n      return resourceFactory<ResFn>()(name, key, actualResource);\n    };\n\n    const handler: ResourceCreatorHandler<Name, Key, CreatorFn> = {\n      name,\n      resource: null,\n      get(target, property) {\n        let result;\n        if (property === this.name) {\n          result = true;\n        } else if (property === key) {\n          if (this.resource === null) {\n            const newResource = creatorFn() as ReturnType<CreatorFn>;\n            this.resource = newResource;\n          }\n          result = this.resource;\n        } else {\n          const targetKey = property as keyof typeof target;\n          result = target[targetKey];\n        }\n\n        return result;\n      },\n      has(target, property) {\n        if (property === this.name || property === key) {\n          return true;\n        }\n\n        const targetKey = property as keyof typeof target;\n        return targetKey in target;\n      },\n    };\n\n    return new Proxy(fnToProxy, handler) as unknown as ResourceCreator<\n      Name,\n      Key,\n      CreatorFn,\n      ResourceFn\n    >;\n  };\n","import { resourceFactory } from './resourceFactory';\nimport type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to configure a collection of resources of an specified type. This\n * function itself doesn't have logic, but it's just in charge of creating the constraint\n * for the resource name and function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to configure a collection of resources.\n * @template ResourceName  The literal type of the name the resources needs to have.\n * @template ResourceFn    The type of function the resources needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourcesCollectionFactory<'action', ActionFn>();\n *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n *\n */\nexport const resourcesCollectionFactory =\n  <ResourceName extends string, ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a function to create a collection of resources of an specified type. A\n   * collection is a dictionary of resources, and a resource itself, and when its\n   * \"resource function\" gets called, it calls the function of every resource (with the\n   * same args it recevied).\n   *\n   * @param name  The resource name the items in the collection must have.\n   * @param key   The key property the items in the collection must have.\n   * @param fn    A custom function to process the items in the collection, when the\n   *              collection function gets called.\n   * @returns A function that can be used to create a resources collection.\n   * @template Name      The literal type of `name`, to be used in the return object.\n   * @template Key       The literal type of `key`, to be used in the return object.\n   * @template ItemKey   To capture the name of the resources in the collection.\n   * @template Items     The kind of dictionary of resources the return function will\n   *                     expect.\n   * @template CustomFn  The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ItemKey extends string,\n    Items extends Record<ItemKey, Resource<ResourceName, Key, ResourceFn>>,\n    CustomFn extends (items: Items, ...rest: Parameters<ResourceFn>) => void,\n  >(\n    name: Name,\n    key: Key,\n    fn?: CustomFn,\n  ) => {\n    const collectionResourceFactory = resourceFactory<ResourceFn>();\n    /**\n     * The actual function that recevies the items and creates the collection.\n     *\n     * @param items  A dictionary of resources for the collection.\n     * @returns A dictionary of the resources, that it's also a resource.\n     * @template ItemsParam  The literal type of `items`, to be used in the return\n     *                       object.\n     * @throws If the dictionary contains the resource name or function key as keys.\n     * @throws If one of the items doesn't have the resource function.\n     */\n    return <ItemsParam>(\n      items: ItemsParam & Items,\n    ): typeof items & Resource<Name, Key, ResourceFn> => {\n      const invalidKeys: string[] = [name, key];\n      const itemsKeys = Object.keys(items) as Array<keyof Items>;\n\n      const invalidKey = itemsKeys.some((itemKey) =>\n        invalidKeys.includes(String(itemKey)),\n      );\n      if (invalidKey) {\n        throw new Error(\n          `No item on the collection can have the keys \\`${name}\\` nor \\`${key}\\``,\n        );\n      }\n\n      const invalidItem = itemsKeys.find(\n        (itemKey) => typeof items[itemKey]?.[key] !== 'function',\n      );\n      if (invalidItem) {\n        throw new Error(\n          `The item \\`${String(\n            invalidItem,\n          )}\\` is invalid: it doesn't have a \\`${key}\\` function`,\n        );\n      }\n\n      const useFn = fn\n        ? (...args: Parameters<ResourceFn>) => fn(items, ...args)\n        : (...args: Parameters<ResourceFn>) => {\n            itemsKeys.forEach((itemK) => {\n              const item = items[itemK]!;\n              const itemFn = item[key];\n              itemFn(...args);\n            });\n          };\n\n      return {\n        ...collectionResourceFactory(name, key, useFn as ResourceFn),\n        ...items,\n      };\n    };\n  };\n","import type { Jimple } from '../jimple';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- They are dynamically extended.\ntype GenericDict = Record<any, any>;\n/**\n * A helper that reusable services can use to resolve dependencies in constructors and/or\n * providers.\n *\n * @template InjectDictionary  A dictionary of the dependencies and their types.\n * @template InjectKey         The literal type of the dictionary types.\n */\nexport class InjectHelper<\n  InjectDictionary extends GenericDict,\n  InjectKey = keyof InjectDictionary,\n> {\n  /**\n   * This method is meant to be used to validate the dependencies a service receives, and\n   * needs.\n   * It will check on the received dependencies, if a specific dependency exists, it will\n   * return it, otherwise, it will create a new instance.\n   *\n   * @param dependencies  The dependencies received by the implementation.\n   * @param key           The key of the dependency to validate.\n   * @param init          A function to create a dependency in case it doesn't exist in\n   *                      the dictionary.\n   * @returns An instance of the dependency.\n   * @template DepKey   The literal key of the dependency to validate.\n   * @template DepType  The type of the dependency, obtained from the dictionary sent\n   *                    to the constructor.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyServiceOptions = {\n   *     inject?: Partial<Dependencies>;\n   *   };\n   *   const myService = ({ inject = {} }: MyServiceOptions) => {\n   *     const dep = helper.get(inject, 'dep', () => 'default');\n   *     console.log('dep:', dep);\n   *   };\n   *\n   */\n  get<DepKey extends InjectKey, DepType = InjectDictionary[DepKey]>(\n    dependencies: Partial<InjectDictionary>,\n    key: InjectKey,\n    init: () => DepType,\n  ): DepType {\n    const existing = dependencies[key];\n    if (typeof existing !== 'undefined') {\n      return existing!;\n    }\n\n    return init();\n  }\n  /**\n   * This is meant to be used in a provider creator to resolve dependencies' names sent as\n   * options. For each dependency, the method will first check if a new name was\n   * specified, and try to get it with that name, otherwise, it will try to get it with\n   * the default name, and if it doesn't exist, it will just keep it as `undefined` and\n   * expect the service implements {@link InjectHelper.get} to ensure the dependency.\n   *\n   * @param dependencies  The dependencies needed by the service.\n   * @param container     A reference to the Jimple container.\n   * @param inject        A dictionary of dependencies names.\n   * @returns A dictionary of dependencies to send to the service.\n   * @template DepKey     The literal key of the dependencies to validate.\n   * @template Container  The type of the Jimple container.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyProviderOptions = {\n   *     services?: {\n   *       [key in keyof Dependencies]?: string;\n   *     };\n   *   };\n   *\n   *   const myProvider = providerCreator(\n   *     ({ services = {} }: MyProviderOptions) =>\n   *       (container) => {\n   *         container.set('myService', () => {\n   *           const inject = helper.resolve(['dep'], container, services);\n   *           return myService({ inject });\n   *         });\n   *       },\n   *   );\n   *\n   */\n  resolve<DepKey extends InjectKey, Container extends Jimple>(\n    dependencies: DepKey[],\n    container: Container,\n    inject: Partial<Record<keyof InjectDictionary, string>>,\n  ): Partial<InjectDictionary> {\n    const result = dependencies.reduce<Partial<InjectDictionary>>((acc, key) => {\n      if (inject[key]) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(inject[key]!);\n        return acc;\n      }\n\n      const keyStr = key as unknown as string;\n      if (container.has(keyStr)) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(keyStr);\n        return acc;\n      }\n\n      return acc;\n    }, {});\n\n    return result;\n  }\n}\n/**\n * Shorthand for `new InjectHelper()`.\n *\n * @returns A new instance of {@link InjectHelper}.\n */\nexport const injectHelper = <InjectDictionary extends GenericDict>() =>\n  new InjectHelper<InjectDictionary>();\n","import type { Jimple } from '../jimple';\nimport { resourceFactory } from '../factories';\n\nexport type ProviderName = 'provider';\nexport type ProviderKey = 'register';\n/**\n * The function the container will call when the provider is registered.\n *\n * @param container  A reference for container where the provider is being registered.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport type ProviderRegisterFn<ContainerType extends Jimple = Jimple> = (\n  container: ContainerType,\n) => void;\n/**\n * Generates a function to create providers for a specific type of container.\n *\n * @returns A function to create providers.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProvider = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourceFactory<RegisterFn>();\n  return (register: RegisterFn) => factory('provider', 'register', register);\n};\n/**\n * Creates a resource to be registered in a Jimple container.\n *\n * @example\n *\n *   export const myService = provider((c) => {\n *     c.set('myService', () => new MyService());\n *   });\n *\n */\nexport const provider = createProvider();\n/**\n * A resource that can be registered in a Jimple container.\n */\nexport type Provider = ReturnType<typeof provider>;\n","import type { Jimple } from '../jimple';\nimport { resourceCreatorFactory, type GenericCurriedFn } from '../factories';\nimport type { ProviderRegisterFn } from './provider';\n/**\n * Generates a function to create \"provider creators\" for a specific type of container.\n *\n * @returns A function to generate provider creators.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviderCreator = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  type ProviderCreatorFn = GenericCurriedFn<RegisterFn>;\n  const factory = resourceCreatorFactory<RegisterFn>();\n  return <CreatorFn extends ProviderCreatorFn>(creator: CreatorFn) =>\n    factory('provider', 'register', creator);\n};\n/**\n * Generates a \"provider creator\": a provider that can also be called as a function in\n * order to create a configured provider.\n *\n * @example\n *\n *   export const myService = providerCreator((options: Opts = {}) => (c) => {\n *     c.set('myService', () => new MyService(options));\n *   });\n *\n */\nexport const providerCreator = createProviderCreator();\n/**\n * A function that returns a provider registration function.\n */\nexport type ProviderCreatorFn = Parameters<typeof providerCreator>[0];\n","import type { Jimple } from '../jimple';\nimport { resourcesCollectionFactory } from '../factories';\nimport type { ProviderRegisterFn, ProviderName } from './provider';\n/**\n * Generates a function to create a providers collection for a specific type of container.\n *\n * @returns A function to create providers collections.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviders = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourcesCollectionFactory<ProviderName, RegisterFn>();\n  return factory('provider', 'register');\n};\n/**\n * Generates a collection of providers. A collection is a dictionary of providers that can\n * also be used as a provider, and when it gets registered, it will register all of the\n * providers in the collection.\n *\n * @param items  A dictionary of providers.\n * @example\n *\n * <caption>Assuming we already have two service providers...</caption>\n *\n *   export const services = providers({\n *     myServiceProvider,\n *     myOtherServiceProvider,\n *   });\n *\n */\nexport const providers = createProviders();\n"],"mappings":"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","names":["Jimple","provider","JimpleOriginal","Jimple"]}

package/dist/index.js

@@ -21,6 +21,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -57,6 +61,10 @@ var require_Jimple = __commonJS({
       static provider(register) {
         return { register };
       }
+      /**
+       * Create a Jimple Container.
+       * @param {Object?} [values] - An optional object whose keys and values will be associated in the container at initialization
+       */
       constructor(values) {
         this._items = {};
         this._instances = /* @__PURE__ */ new Map();
@@ -67,6 +75,13 @@ var require_Jimple = __commonJS({
           this.set(key, values[key]);
         }, this);
       }
+      /**
+       * Return the specified parameter or service. If the service is not built yet, this function will construct the service
+       * injecting all the dependencies needed in it's definition so the returned object is totally usable on the fly.
+       * @param {string} key - The key of the parameter or service to return
+       * @return {*} The object related to the service or the value of the parameter associated with the key informed
+       * @throws If the key does not exist
+       */
       get(key) {
         checkDefined(this, key);
         let item = this._items[key];
@@ -87,21 +102,53 @@ var require_Jimple = __commonJS({
         }
         return obj;
       }
+      /**
+       * Defines a new parameter or service.
+       * @param {string} key - The key of the parameter or service to be defined
+       * @param {*} value - The value of the parameter or a function that receives the container as parameter and constructs the service
+       */
       set(key, value) {
         this._items[key] = value;
       }
+      /**
+       * Returns if a service or parameter with the informed key is already defined in the container.
+       * @param {string} key - The key of the parameter or service to be checked.
+       * @return {boolean} If the key exists in the container or not
+       */
       has(key) {
         return this._items.hasOwnProperty(key);
       }
+      /**
+       * Defines a service as a factory, so the instances are not cached in the service and that function is always called
+       * @param {function(Jimple):*} fn - The function that constructs the service that is a factory
+       * @return {function(Jimple):*} The same function passed as parameter
+       */
       factory(fn) {
         return addFunctionTo(this._factories, fn);
       }
+      /**
+       * Defines a function as a parameter, so that function is not considered a service
+       * @param {*} fn - The function to not be considered a service
+       * @return {*} The same function passed as parameter
+       */
       protect(fn) {
         return addFunctionTo(this._protected, fn);
       }
+      /**
+       * Return all the keys registered in the container
+       * @returns {Array<string>}
+       */
       keys() {
         return Object.keys(this._items);
       }
+      /**
+       * Extends a service already registered in the container
+       * @param {string} key - The key of the service to be extended
+       * @param {function(*, Jimple):*} fn - The function that will be used to extend the service
+       * @throws If the key is not already defined
+       * @throws If the key saved in the container does not correspond to a service
+       * @throws If the function passed it not...well, a function
+       */
       extend(key, fn) {
         checkDefined(this, key);
         let originalItem = this._items[key];
@@ -115,9 +162,20 @@ var require_Jimple = __commonJS({
           this._factories.add(this._items[key]);
         }
       }
+      /**
+       * Uses an provider to extend the service, so it's easy to split the service and parameter definitions across the system
+       * @param {{register: function(Jimple)}} provider - The provider to be used to register services and parameters in this container
+       */
       register(provider2) {
         provider2.register(this);
       }
+      /**
+       * Returns the raw value of a service or parameter. So, in the case of a service, for example, the value returned is the
+       * function used to construct the service.
+       * @param {string} key - The key of the service or parameter to return.
+       * @throws If the key does not exist in the container
+       * @return {*} The raw value of the service or parameter
+       */
       raw(key) {
         checkDefined(this, key);
         return this._items[key];
@@ -152,6 +210,15 @@ var Jimple = import_jimple.default;
 
 // src/jimple/index.ts
 var Jimple2 = class extends Jimple {
+  /**
+   * This is a version of the `get` method that doesn't throw if the key doesn't exist. It
+   * will return `undefined` instead.
+   *
+   * @param key  The key of the parameter or service to return.
+   * @returns The object related to the service or the value of the parameter
+   *          associated with the given key.
+   * @template T  The type of the returned object.
+   */
   try(key) {
     if (!this.has(key)) {
       return void 0;
@@ -162,87 +229,183 @@ var Jimple2 = class extends Jimple {
 var jimple = (...args) => new Jimple2(...args);
 
 // src/factories/resourceFactory.ts
-var resourceFactory = () => (name, key, fn) => ({
-  [name]: true,
-  [key]: fn
-});
+var resourceFactory = () => (
+  /**
+   * Generates a new resource using the contraint defined in the factory.
+   *
+   * @param name  The name of the resource.
+   * @param key   The property key for the function.
+   * @param fn    The resource function.
+   * @returns An object with the `name` set to `true`, and the `fn` as the `key`.
+   * @template Name  The literal type of `name`, to be used in the return object.
+   * @template Key   The literal type of `key`, to be used in the return object.
+   * @template Fn    The type of `fn`, restricted by the factory constraint.
+   * @example
+   *
+   *   const myAction = factory('action', 'fn', (c) => {
+   *     c.set('foo', 'bar');
+   *   });
+   *
+   */
+  (name, key, fn) => ({
+    [name]: true,
+    [key]: fn
+  })
+);
 
 // src/factories/resourceCreatorFactory.ts
-var resourceCreatorFactory = () => (name, key, creatorFn) => {
-  const fnToProxy = (...args) => {
-    const actualResource = creatorFn(...args);
-    return resourceFactory()(name, key, actualResource);
-  };
-  const handler = {
-    name,
-    resource: null,
-    get(target, property) {
-      let result;
-      if (property === this.name) {
-        result = true;
-      } else if (property === key) {
-        if (this.resource === null) {
-          const newResource = creatorFn();
-          this.resource = newResource;
+var resourceCreatorFactory = () => (
+  /**
+   * Generates a new resource creator using the contraint defined in the factory.
+   *
+   * @param name       The name of the resource.
+   * @param key        The property key for the function.
+   * @param creatorFn  The curried function that returns the actual resource function.
+   * @returns A resource creator: an object that can be used as a resource, and as a
+   *          function that returns a resource.
+   * @template Name       The literal type of `name`, to be used in the return object.
+   * @template Key        The literal type of `key`, to be used in the return object.
+   * @template ResFn      The type of the resource function, the creator function needs
+   *                      to return. This is restricted by the factory constraint.
+   * @template CreatorFn  The literal type of `creatorFn`, to be used in the return
+   *                      object.
+   * @example
+   *
+   *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {
+   *     c.set(name, 'bar');
+   *   });
+   *
+   */
+  (name, key, creatorFn) => {
+    const fnToProxy = (...args) => {
+      const actualResource = creatorFn(...args);
+      return resourceFactory()(name, key, actualResource);
+    };
+    const handler = {
+      name,
+      resource: null,
+      get(target, property) {
+        let result;
+        if (property === this.name) {
+          result = true;
+        } else if (property === key) {
+          if (this.resource === null) {
+            const newResource = creatorFn();
+            this.resource = newResource;
+          }
+          result = this.resource;
+        } else {
+          const targetKey = property;
+          result = target[targetKey];
+        }
+        return result;
+      },
+      has(target, property) {
+        if (property === this.name || property === key) {
+          return true;
         }
-        result = this.resource;
-      } else {
         const targetKey = property;
-        result = target[targetKey];
+        return targetKey in target;
       }
-      return result;
-    },
-    has(target, property) {
-      if (property === this.name || property === key) {
-        return true;
-      }
-      const targetKey = property;
-      return targetKey in target;
-    }
-  };
-  return new Proxy(fnToProxy, handler);
-};
+    };
+    return new Proxy(fnToProxy, handler);
+  }
+);
 
 // src/factories/resourcesCollectionFactory.ts
-var resourcesCollectionFactory = () => (name, key, fn) => {
-  const collectionResourceFactory = resourceFactory();
-  return (items) => {
-    const invalidKeys = [name, key];
-    const itemsKeys = Object.keys(items);
-    const invalidKey = itemsKeys.some(
-      (itemKey) => invalidKeys.includes(String(itemKey))
-    );
-    if (invalidKey) {
-      throw new Error(
-        `No item on the collection can have the keys \`${name}\` nor \`${key}\``
+var resourcesCollectionFactory = () => (
+  /**
+   * Generates a function to create a collection of resources of an specified type. A
+   * collection is a dictionary of resources, and a resource itself, and when its
+   * "resource function" gets called, it calls the function of every resource (with the
+   * same args it recevied).
+   *
+   * @param name  The resource name the items in the collection must have.
+   * @param key   The key property the items in the collection must have.
+   * @param fn    A custom function to process the items in the collection, when the
+   *              collection function gets called.
+   * @returns A function that can be used to create a resources collection.
+   * @template Name      The literal type of `name`, to be used in the return object.
+   * @template Key       The literal type of `key`, to be used in the return object.
+   * @template ItemKey   To capture the name of the resources in the collection.
+   * @template Items     The kind of dictionary of resources the return function will
+   *                     expect.
+   * @template CustomFn  The type of `fn`, restricted by the factory constraint.
+   * @example
+   *
+   *   const myActions = factory('action', 'fn')({ myActionA, myActionB });
+   *
+   */
+  (name, key, fn) => {
+    const collectionResourceFactory = resourceFactory();
+    return (items) => {
+      const invalidKeys = [name, key];
+      const itemsKeys = Object.keys(items);
+      const invalidKey = itemsKeys.some(
+        (itemKey) => invalidKeys.includes(String(itemKey))
       );
-    }
-    const invalidItem = itemsKeys.find(
-      (itemKey) => typeof items[itemKey]?.[key] !== "function"
-    );
-    if (invalidItem) {
-      throw new Error(
-        `The item \`${String(
-          invalidItem
-        )}\` is invalid: it doesn't have a \`${key}\` function`
+      if (invalidKey) {
+        throw new Error(
+          `No item on the collection can have the keys \`${name}\` nor \`${key}\``
+        );
+      }
+      const invalidItem = itemsKeys.find(
+        (itemKey) => typeof items[itemKey]?.[key] !== "function"
       );
-    }
-    const useFn = fn ? (...args) => fn(items, ...args) : (...args) => {
-      itemsKeys.forEach((itemK) => {
-        const item = items[itemK];
-        const itemFn = item[key];
-        itemFn(...args);
-      });
-    };
-    return {
-      ...collectionResourceFactory(name, key, useFn),
-      ...items
+      if (invalidItem) {
+        throw new Error(
+          `The item \`${String(
+            invalidItem
+          )}\` is invalid: it doesn't have a \`${key}\` function`
+        );
+      }
+      const useFn = fn ? (...args) => fn(items, ...args) : (...args) => {
+        itemsKeys.forEach((itemK) => {
+          const item = items[itemK];
+          const itemFn = item[key];
+          itemFn(...args);
+        });
+      };
+      return {
+        ...collectionResourceFactory(name, key, useFn),
+        ...items
+      };
     };
-  };
-};
+  }
+);
 
 // src/helpers/injectHelper.ts
 var InjectHelper = class {
+  /**
+   * This method is meant to be used to validate the dependencies a service receives, and
+   * needs.
+   * It will check on the received dependencies, if a specific dependency exists, it will
+   * return it, otherwise, it will create a new instance.
+   *
+   * @param dependencies  The dependencies received by the implementation.
+   * @param key           The key of the dependency to validate.
+   * @param init          A function to create a dependency in case it doesn't exist in
+   *                      the dictionary.
+   * @returns An instance of the dependency.
+   * @template DepKey   The literal key of the dependency to validate.
+   * @template DepType  The type of the dependency, obtained from the dictionary sent
+   *                    to the constructor.
+   * @example
+   *
+   *   type Dependencies = {
+   *     dep: string;
+   *   };
+   *   const helper = new InjectHelper<Dependencies>();
+   *
+   *   type MyServiceOptions = {
+   *     inject?: Partial<Dependencies>;
+   *   };
+   *   const myService = ({ inject = {} }: MyServiceOptions) => {
+   *     const dep = helper.get(inject, 'dep', () => 'default');
+   *     console.log('dep:', dep);
+   *   };
+   *
+   */
   get(dependencies, key, init) {
     const existing = dependencies[key];
     if (typeof existing !== "undefined") {
@@ -250,6 +413,43 @@ var InjectHelper = class {
     }
     return init();
   }
+  /**
+   * This is meant to be used in a provider creator to resolve dependencies' names sent as
+   * options. For each dependency, the method will first check if a new name was
+   * specified, and try to get it with that name, otherwise, it will try to get it with
+   * the default name, and if it doesn't exist, it will just keep it as `undefined` and
+   * expect the service implements {@link InjectHelper.get} to ensure the dependency.
+   *
+   * @param dependencies  The dependencies needed by the service.
+   * @param container     A reference to the Jimple container.
+   * @param inject        A dictionary of dependencies names.
+   * @returns A dictionary of dependencies to send to the service.
+   * @template DepKey     The literal key of the dependencies to validate.
+   * @template Container  The type of the Jimple container.
+   * @example
+   *
+   *   type Dependencies = {
+   *     dep: string;
+   *   };
+   *   const helper = new InjectHelper<Dependencies>();
+   *
+   *   type MyProviderOptions = {
+   *     services?: {
+   *       [key in keyof Dependencies]?: string;
+   *     };
+   *   };
+   *
+   *   const myProvider = providerCreator(
+   *     ({ services = {} }: MyProviderOptions) =>
+   *       (container) => {
+   *         container.set('myService', () => {
+   *           const inject = helper.resolve(['dep'], container, services);
+   *           return myService({ inject });
+   *         });
+   *       },
+   *   );
+   *
+   */
   resolve(dependencies, container, inject) {
     const result = dependencies.reduce((acc, key) => {
       if (inject[key]) {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../node_modules/jimple/src/Jimple.js","../src/index.ts","../src/jimplemod/index.ts","../src/jimple/index.ts","../src/factories/resourceFactory.ts","../src/factories/resourceCreatorFactory.ts","../src/factories/resourcesCollectionFactory.ts","../src/helpers/injectHelper.ts","../src/helpers/provider.ts","../src/helpers/providerCreator.ts","../src/helpers/providers.ts"],"sourcesContent":["\"use strict\";\n\nfunction assert(ok, message) {\n    if (!ok) {\n        throw new Error(message)\n    }\n}\n\nfunction isFunction(fn) {\n    return Object.prototype.toString.call(fn) === \"[object Function]\" && fn.constructor.name === \"Function\";\n}\n\nfunction isPlainObject(value) {\n    if (Object.prototype.toString.call(value) !== '[object Object]') {\n        return false;\n    }\n    let prototype = Object.getPrototypeOf(value);\n    return prototype === null || prototype === Object.prototype;\n}\n\nfunction checkDefined(container, key) {\n    assert(container.has(key), `Identifier \"${key}\" is not defined.`);\n}\n\nfunction addFunctionTo(set, fn) {\n    assert(isFunction(fn), \"Service definition is not a Closure or invokable object\");\n    set.add(fn);\n    return fn;\n}\n\n/**\n * The Jimple Container class\n *\n * @public\n */\nclass Jimple {\n    static provider(register) {\n      return ({ register });\n    }\n    /**\n     * Create a Jimple Container.\n     * @param {Object?} [values] - An optional object whose keys and values will be associated in the container at initialization\n     */\n    constructor(values) {\n        this._items = {};\n        this._instances = new Map();\n        this._factories = new Set();\n        this._protected = new Set();\n        values = isPlainObject(values) ? values : {};\n        Object.keys(values).forEach(function(key) {\n            this.set(key, values[key]);\n        }, this);\n    }\n    /**\n     * Return the specified parameter or service. If the service is not built yet, this function will construct the service\n     * injecting all the dependencies needed in it's definition so the returned object is totally usable on the fly.\n     * @param {string} key - The key of the parameter or service to return\n     * @return {*} The object related to the service or the value of the parameter associated with the key informed\n     * @throws If the key does not exist\n     */\n    get(key) {\n        checkDefined(this, key);\n        let item = this._items[key];\n        let obj;\n        if (isFunction(item)) {\n            if (this._protected.has(item)) {\n                obj = item;\n            } else if (this._instances.has(item)) {\n                obj = this._instances.get(item);\n            } else {\n                obj = item(this);\n                if (!this._factories.has(item)) {\n                    this._instances.set(item, obj);\n                }\n            }\n        } else {\n            obj = item;\n        }\n        return obj;\n    }\n    /**\n     * Defines a new parameter or service.\n     * @param {string} key - The key of the parameter or service to be defined\n     * @param {*} value - The value of the parameter or a function that receives the container as parameter and constructs the service\n     */\n    set(key, value) {\n        this._items[key] = value;\n    }\n\n    /**\n     * Returns if a service or parameter with the informed key is already defined in the container.\n     * @param {string} key - The key of the parameter or service to be checked.\n     * @return {boolean} If the key exists in the container or not\n     */\n    has(key) {\n        return this._items.hasOwnProperty(key);\n    }\n\n    /**\n     * Defines a service as a factory, so the instances are not cached in the service and that function is always called\n     * @param {function(Jimple):*} fn - The function that constructs the service that is a factory\n     * @return {function(Jimple):*} The same function passed as parameter\n     */\n    factory(fn) {\n        return addFunctionTo(this._factories, fn);\n    }\n\n    /**\n     * Defines a function as a parameter, so that function is not considered a service\n     * @param {*} fn - The function to not be considered a service\n     * @return {*} The same function passed as parameter\n     */\n    protect(fn) {\n        return addFunctionTo(this._protected, fn);\n    }\n\n    /**\n     * Return all the keys registered in the container\n     * @returns {Array<string>}\n     */\n    keys() {\n        return Object.keys(this._items);\n    }\n\n    /**\n     * Extends a service already registered in the container\n     * @param {string} key - The key of the service to be extended\n     * @param {function(*, Jimple):*} fn - The function that will be used to extend the service\n     * @throws If the key is not already defined\n     * @throws If the key saved in the container does not correspond to a service\n     * @throws If the function passed it not...well, a function\n     */\n    extend(key, fn) {\n        checkDefined(this, key);\n        let originalItem = this._items[key];\n        assert(isFunction(originalItem) && this._protected.has(originalItem) === false, `Identifier '${key}' does not contain a service definition`);\n        assert(isFunction(fn), `The 'new' service definition for '${key}' is not a invokable object.`);\n        this._items[key] = function(app) {\n            return fn(originalItem(app), app);\n        }\n        if (this._factories.has(originalItem)) {\n            this._factories.delete(originalItem);\n            this._factories.add(this._items[key]);\n        }\n    }\n\n    /**\n     * Uses an provider to extend the service, so it's easy to split the service and parameter definitions across the system\n     * @param {{register: function(Jimple)}} provider - The provider to be used to register services and parameters in this container\n     */\n    register(provider) {\n        provider.register(this);\n    }\n\n    /**\n     * Returns the raw value of a service or parameter. So, in the case of a service, for example, the value returned is the\n     * function used to construct the service.\n     * @param {string} key - The key of the service or parameter to return.\n     * @throws If the key does not exist in the container\n     * @return {*} The raw value of the service or parameter\n     */\n    raw(key) {\n        checkDefined(this, key);\n        return this._items[key];\n    }\n}\n\nmodule.exports = Jimple;\n","export * from './jimple';\nexport * from './factories';\nexport * from './helpers';\n","// @ts-expect-error - the idea is to have `any` and assert on export.\nimport JimpleOriginal from 'jimple';\nimport { Container as JimpleContainer } from './jimple.type';\n\nconst Jimple = JimpleOriginal as typeof JimpleContainer;\n\nexport { Jimple };\nexport type { JimpleContainer };\n","import { Jimple as JimpleMod } from '../jimplemod';\n\nexport class Jimple extends JimpleMod {\n  /**\n   * This is a version of the `get` method that doesn't throw if the key doesn't exist. It\n   * will return `undefined` instead.\n   *\n   * @param key  The key of the parameter or service to return.\n   * @returns The object related to the service or the value of the parameter\n   *          associated with the given key.\n   * @template T  The type of the returned object.\n   */\n  try<T = unknown>(key: string): T | undefined {\n    if (!this.has(key)) {\n      return undefined;\n    }\n\n    return this.get<T>(key);\n  }\n}\n/**\n * Shorthand for `new Jimple()`.\n *\n * @param args  The same parameters as the {@link Jimple} constructor.\n * @returns A new instance of {@link Jimple}.\n */\nexport const jimple = (...args: ConstructorParameters<typeof Jimple>): Jimple =>\n  new Jimple(...args);\n","import type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to create resources of an specified type. This function itself\n * doesn't have logic, but it's just in charge of creating the constraint for the resource\n * function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create a resource with a specified type of\n *          function.\n * @template ResourceFn  The type of function the resource needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (c) => {\n *     c.set('foo', 'bar');\n *   });\n *\n */\nexport const resourceFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource using the contraint defined in the factory.\n   *\n   * @param name  The name of the resource.\n   * @param key   The property key for the function.\n   * @param fn    The resource function.\n   * @returns An object with the `name` set to `true`, and the `fn` as the `key`.\n   * @template Name  The literal type of `name`, to be used in the return object.\n   * @template Key   The literal type of `key`, to be used in the return object.\n   * @template Fn    The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (c) => {\n   *     c.set('foo', 'bar');\n   *   });\n   *\n   */\n  <Name extends string, Key extends string, Fn extends ResourceFn>(\n    name: Name,\n    key: Key,\n    fn: Fn,\n  ): Resource<Name, Key, Fn> =>\n    ({\n      [name]: true,\n      [key]: fn,\n    } as Resource<Name, Key, Fn>);\n","import { resourceFactory } from './resourceFactory';\nimport type {\n  GenericFn,\n  GenericCurriedFn,\n  ResourceCreator,\n  ResourceCreatorCurriedFn,\n  ResourceCreatorHandler,\n} from './factories.types';\n/**\n * Generates a function to create resource creators of an specified type. This function\n * itself doesn't have logic, but it's just in charge of creating the constraint for the\n * resource creator function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create \"resource creators\".\n * @template ResourceFn  The type of function the resource creator needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceCreatorFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n *     c.set(name, 'bar');\n *   });\n *\n */\nexport const resourceCreatorFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource creator using the contraint defined in the factory.\n   *\n   * @param name       The name of the resource.\n   * @param key        The property key for the function.\n   * @param creatorFn  The curried function that returns the actual resource function.\n   * @returns A resource creator: an object that can be used as a resource, and as a\n   *          function that returns a resource.\n   * @template Name       The literal type of `name`, to be used in the return object.\n   * @template Key        The literal type of `key`, to be used in the return object.\n   * @template ResFn      The type of the resource function, the creator function needs\n   *                      to return. This is restricted by the factory constraint.\n   * @template CreatorFn  The literal type of `creatorFn`, to be used in the return\n   *                      object.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n   *     c.set(name, 'bar');\n   *   });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ResFn extends ResourceFn,\n    CreatorFn extends GenericCurriedFn<ResFn>,\n  >(\n    name: Name,\n    key: Key,\n    creatorFn: CreatorFn,\n  ): ResourceCreator<Name, Key, CreatorFn, ResourceFn> => {\n    const fnToProxy: ResourceCreatorCurriedFn<Name, Key, CreatorFn> = (...args) => {\n      const actualResource = creatorFn(...args) as ReturnType<CreatorFn>;\n      return resourceFactory<ResFn>()(name, key, actualResource);\n    };\n\n    const handler: ResourceCreatorHandler<Name, Key, CreatorFn> = {\n      name,\n      resource: null,\n      get(target, property) {\n        let result;\n        if (property === this.name) {\n          result = true;\n        } else if (property === key) {\n          if (this.resource === null) {\n            const newResource = creatorFn() as ReturnType<CreatorFn>;\n            this.resource = newResource;\n          }\n          result = this.resource;\n        } else {\n          const targetKey = property as keyof typeof target;\n          result = target[targetKey];\n        }\n\n        return result;\n      },\n      has(target, property) {\n        if (property === this.name || property === key) {\n          return true;\n        }\n\n        const targetKey = property as keyof typeof target;\n        return targetKey in target;\n      },\n    };\n\n    return new Proxy(fnToProxy, handler) as unknown as ResourceCreator<\n      Name,\n      Key,\n      CreatorFn,\n      ResourceFn\n    >;\n  };\n","import { resourceFactory } from './resourceFactory';\nimport type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to configure a collection of resources of an specified type. This\n * function itself doesn't have logic, but it's just in charge of creating the constraint\n * for the resource name and function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to configure a collection of resources.\n * @template ResourceName  The literal type of the name the resources needs to have.\n * @template ResourceFn    The type of function the resources needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourcesCollectionFactory<'action', ActionFn>();\n *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n *\n */\nexport const resourcesCollectionFactory =\n  <ResourceName extends string, ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a function to create a collection of resources of an specified type. A\n   * collection is a dictionary of resources, and a resource itself, and when its\n   * \"resource function\" gets called, it calls the function of every resource (with the\n   * same args it recevied).\n   *\n   * @param name  The resource name the items in the collection must have.\n   * @param key   The key property the items in the collection must have.\n   * @param fn    A custom function to process the items in the collection, when the\n   *              collection function gets called.\n   * @returns A function that can be used to create a resources collection.\n   * @template Name      The literal type of `name`, to be used in the return object.\n   * @template Key       The literal type of `key`, to be used in the return object.\n   * @template ItemKey   To capture the name of the resources in the collection.\n   * @template Items     The kind of dictionary of resources the return function will\n   *                     expect.\n   * @template CustomFn  The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ItemKey extends string,\n    Items extends Record<ItemKey, Resource<ResourceName, Key, ResourceFn>>,\n    CustomFn extends (items: Items, ...rest: Parameters<ResourceFn>) => void,\n  >(\n    name: Name,\n    key: Key,\n    fn?: CustomFn,\n  ) => {\n    const collectionResourceFactory = resourceFactory<ResourceFn>();\n    /**\n     * The actual function that recevies the items and creates the collection.\n     *\n     * @param items  A dictionary of resources for the collection.\n     * @returns A dictionary of the resources, that it's also a resource.\n     * @template ItemsParam  The literal type of `items`, to be used in the return\n     *                       object.\n     * @throws If the dictionary contains the resource name or function key as keys.\n     * @throws If one of the items doesn't have the resource function.\n     */\n    return <ItemsParam>(\n      items: ItemsParam & Items,\n    ): typeof items & Resource<Name, Key, ResourceFn> => {\n      const invalidKeys: string[] = [name, key];\n      const itemsKeys = Object.keys(items) as Array<keyof Items>;\n\n      const invalidKey = itemsKeys.some((itemKey) =>\n        invalidKeys.includes(String(itemKey)),\n      );\n      if (invalidKey) {\n        throw new Error(\n          `No item on the collection can have the keys \\`${name}\\` nor \\`${key}\\``,\n        );\n      }\n\n      const invalidItem = itemsKeys.find(\n        (itemKey) => typeof items[itemKey]?.[key] !== 'function',\n      );\n      if (invalidItem) {\n        throw new Error(\n          `The item \\`${String(\n            invalidItem,\n          )}\\` is invalid: it doesn't have a \\`${key}\\` function`,\n        );\n      }\n\n      const useFn = fn\n        ? (...args: Parameters<ResourceFn>) => fn(items, ...args)\n        : (...args: Parameters<ResourceFn>) => {\n            itemsKeys.forEach((itemK) => {\n              const item = items[itemK]!;\n              const itemFn = item[key];\n              itemFn(...args);\n            });\n          };\n\n      return {\n        ...collectionResourceFactory(name, key, useFn as ResourceFn),\n        ...items,\n      };\n    };\n  };\n","import type { Jimple } from '../jimple';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- They are dynamically extended.\ntype GenericDict = Record<any, any>;\n/**\n * A helper that reusable services can use to resolve dependencies in constructors and/or\n * providers.\n *\n * @template InjectDictionary  A dictionary of the dependencies and their types.\n * @template InjectKey         The literal type of the dictionary types.\n */\nexport class InjectHelper<\n  InjectDictionary extends GenericDict,\n  InjectKey = keyof InjectDictionary,\n> {\n  /**\n   * This method is meant to be used to validate the dependencies a service receives, and\n   * needs.\n   * It will check on the received dependencies, if a specific dependency exists, it will\n   * return it, otherwise, it will create a new instance.\n   *\n   * @param dependencies  The dependencies received by the implementation.\n   * @param key           The key of the dependency to validate.\n   * @param init          A function to create a dependency in case it doesn't exist in\n   *                      the dictionary.\n   * @returns An instance of the dependency.\n   * @template DepKey   The literal key of the dependency to validate.\n   * @template DepType  The type of the dependency, obtained from the dictionary sent\n   *                    to the constructor.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyServiceOptions = {\n   *     inject?: Partial<Dependencies>;\n   *   };\n   *   const myService = ({ inject = {} }: MyServiceOptions) => {\n   *     const dep = helper.get(inject, 'dep', () => 'default');\n   *     console.log('dep:', dep);\n   *   };\n   *\n   */\n  get<DepKey extends InjectKey, DepType = InjectDictionary[DepKey]>(\n    dependencies: Partial<InjectDictionary>,\n    key: InjectKey,\n    init: () => DepType,\n  ): DepType {\n    const existing = dependencies[key];\n    if (typeof existing !== 'undefined') {\n      return existing!;\n    }\n\n    return init();\n  }\n  /**\n   * This is meant to be used in a provider creator to resolve dependencies' names sent as\n   * options. For each dependency, the method will first check if a new name was\n   * specified, and try to get it with that name, otherwise, it will try to get it with\n   * the default name, and if it doesn't exist, it will just keep it as `undefined` and\n   * expect the service implements {@link InjectHelper.get} to ensure the dependency.\n   *\n   * @param dependencies  The dependencies needed by the service.\n   * @param container     A reference to the Jimple container.\n   * @param inject        A dictionary of dependencies names.\n   * @returns A dictionary of dependencies to send to the service.\n   * @template DepKey     The literal key of the dependencies to validate.\n   * @template Container  The type of the Jimple container.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyProviderOptions = {\n   *     services?: {\n   *       [key in keyof Dependencies]?: string;\n   *     };\n   *   };\n   *\n   *   const myProvider = providerCreator(\n   *     ({ services = {} }: MyProviderOptions) =>\n   *       (container) => {\n   *         container.set('myService', () => {\n   *           const inject = helper.resolve(['dep'], container, services);\n   *           return myService({ inject });\n   *         });\n   *       },\n   *   );\n   *\n   */\n  resolve<DepKey extends InjectKey, Container extends Jimple>(\n    dependencies: DepKey[],\n    container: Container,\n    inject: Partial<Record<keyof InjectDictionary, string>>,\n  ): Partial<InjectDictionary> {\n    const result = dependencies.reduce<Partial<InjectDictionary>>((acc, key) => {\n      if (inject[key]) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(inject[key]!);\n        return acc;\n      }\n\n      const keyStr = key as unknown as string;\n      if (container.has(keyStr)) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(keyStr);\n        return acc;\n      }\n\n      return acc;\n    }, {});\n\n    return result;\n  }\n}\n/**\n * Shorthand for `new InjectHelper()`.\n *\n * @returns A new instance of {@link InjectHelper}.\n */\nexport const injectHelper = <InjectDictionary extends GenericDict>() =>\n  new InjectHelper<InjectDictionary>();\n","import type { Jimple } from '../jimple';\nimport { resourceFactory } from '../factories';\n\nexport type ProviderName = 'provider';\nexport type ProviderKey = 'register';\n/**\n * The function the container will call when the provider is registered.\n *\n * @param container  A reference for container where the provider is being registered.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport type ProviderRegisterFn<ContainerType extends Jimple = Jimple> = (\n  container: ContainerType,\n) => void;\n/**\n * Generates a function to create providers for a specific type of container.\n *\n * @returns A function to create providers.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProvider = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourceFactory<RegisterFn>();\n  return (register: RegisterFn) => factory('provider', 'register', register);\n};\n/**\n * Creates a resource to be registered in a Jimple container.\n *\n * @example\n *\n *   export const myService = provider((c) => {\n *     c.set('myService', () => new MyService());\n *   });\n *\n */\nexport const provider = createProvider();\n/**\n * A resource that can be registered in a Jimple container.\n */\nexport type Provider = ReturnType<typeof provider>;\n","import type { Jimple } from '../jimple';\nimport { resourceCreatorFactory, type GenericCurriedFn } from '../factories';\nimport type { ProviderRegisterFn } from './provider';\n/**\n * Generates a function to create \"provider creators\" for a specific type of container.\n *\n * @returns A function to generate provider creators.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviderCreator = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  type ProviderCreatorFn = GenericCurriedFn<RegisterFn>;\n  const factory = resourceCreatorFactory<RegisterFn>();\n  return <CreatorFn extends ProviderCreatorFn>(creator: CreatorFn) =>\n    factory('provider', 'register', creator);\n};\n/**\n * Generates a \"provider creator\": a provider that can also be called as a function in\n * order to create a configured provider.\n *\n * @example\n *\n *   export const myService = providerCreator((options: Opts = {}) => (c) => {\n *     c.set('myService', () => new MyService(options));\n *   });\n *\n */\nexport const providerCreator = createProviderCreator();\n/**\n * A function that returns a provider registration function.\n */\nexport type ProviderCreatorFn = Parameters<typeof providerCreator>[0];\n","import type { Jimple } from '../jimple';\nimport { resourcesCollectionFactory } from '../factories';\nimport type { ProviderRegisterFn, ProviderName } from './provider';\n/**\n * Generates a function to create a providers collection for a specific type of container.\n *\n * @returns A function to create providers collections.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviders = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourcesCollectionFactory<ProviderName, RegisterFn>();\n  return factory('provider', 'register');\n};\n/**\n * Generates a collection of providers. A collection is a dictionary of providers that can\n * also be used as a provider, and when it gets registered, it will register all of the\n * providers in the collection.\n *\n * @param items  A dictionary of providers.\n * @example\n *\n * <caption>Assuming we already have two service providers...</caption>\n *\n *   export const services = providers({\n *     myServiceProvider,\n *     myOtherServiceProvider,\n *   });\n *\n */\nexport const providers = createProviders();\n"],"mappings":"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","names":["module","Jimple","provider","Jimple","JimpleOriginal","Jimple"]}
+{"version":3,"sources":["../../../../node_modules/jimple/src/Jimple.js","../src/index.ts","../src/jimplemod/index.ts","../src/jimple/index.ts","../src/factories/resourceFactory.ts","../src/factories/resourceCreatorFactory.ts","../src/factories/resourcesCollectionFactory.ts","../src/helpers/injectHelper.ts","../src/helpers/provider.ts","../src/helpers/providerCreator.ts","../src/helpers/providers.ts"],"sourcesContent":["\"use strict\";\n\nfunction assert(ok, message) {\n    if (!ok) {\n        throw new Error(message)\n    }\n}\n\nfunction isFunction(fn) {\n    return Object.prototype.toString.call(fn) === \"[object Function]\" && fn.constructor.name === \"Function\";\n}\n\nfunction isPlainObject(value) {\n    if (Object.prototype.toString.call(value) !== '[object Object]') {\n        return false;\n    }\n    let prototype = Object.getPrototypeOf(value);\n    return prototype === null || prototype === Object.prototype;\n}\n\nfunction checkDefined(container, key) {\n    assert(container.has(key), `Identifier \"${key}\" is not defined.`);\n}\n\nfunction addFunctionTo(set, fn) {\n    assert(isFunction(fn), \"Service definition is not a Closure or invokable object\");\n    set.add(fn);\n    return fn;\n}\n\n/**\n * The Jimple Container class\n *\n * @public\n */\nclass Jimple {\n    static provider(register) {\n      return ({ register });\n    }\n    /**\n     * Create a Jimple Container.\n     * @param {Object?} [values] - An optional object whose keys and values will be associated in the container at initialization\n     */\n    constructor(values) {\n        this._items = {};\n        this._instances = new Map();\n        this._factories = new Set();\n        this._protected = new Set();\n        values = isPlainObject(values) ? values : {};\n        Object.keys(values).forEach(function(key) {\n            this.set(key, values[key]);\n        }, this);\n    }\n    /**\n     * Return the specified parameter or service. If the service is not built yet, this function will construct the service\n     * injecting all the dependencies needed in it's definition so the returned object is totally usable on the fly.\n     * @param {string} key - The key of the parameter or service to return\n     * @return {*} The object related to the service or the value of the parameter associated with the key informed\n     * @throws If the key does not exist\n     */\n    get(key) {\n        checkDefined(this, key);\n        let item = this._items[key];\n        let obj;\n        if (isFunction(item)) {\n            if (this._protected.has(item)) {\n                obj = item;\n            } else if (this._instances.has(item)) {\n                obj = this._instances.get(item);\n            } else {\n                obj = item(this);\n                if (!this._factories.has(item)) {\n                    this._instances.set(item, obj);\n                }\n            }\n        } else {\n            obj = item;\n        }\n        return obj;\n    }\n    /**\n     * Defines a new parameter or service.\n     * @param {string} key - The key of the parameter or service to be defined\n     * @param {*} value - The value of the parameter or a function that receives the container as parameter and constructs the service\n     */\n    set(key, value) {\n        this._items[key] = value;\n    }\n\n    /**\n     * Returns if a service or parameter with the informed key is already defined in the container.\n     * @param {string} key - The key of the parameter or service to be checked.\n     * @return {boolean} If the key exists in the container or not\n     */\n    has(key) {\n        return this._items.hasOwnProperty(key);\n    }\n\n    /**\n     * Defines a service as a factory, so the instances are not cached in the service and that function is always called\n     * @param {function(Jimple):*} fn - The function that constructs the service that is a factory\n     * @return {function(Jimple):*} The same function passed as parameter\n     */\n    factory(fn) {\n        return addFunctionTo(this._factories, fn);\n    }\n\n    /**\n     * Defines a function as a parameter, so that function is not considered a service\n     * @param {*} fn - The function to not be considered a service\n     * @return {*} The same function passed as parameter\n     */\n    protect(fn) {\n        return addFunctionTo(this._protected, fn);\n    }\n\n    /**\n     * Return all the keys registered in the container\n     * @returns {Array<string>}\n     */\n    keys() {\n        return Object.keys(this._items);\n    }\n\n    /**\n     * Extends a service already registered in the container\n     * @param {string} key - The key of the service to be extended\n     * @param {function(*, Jimple):*} fn - The function that will be used to extend the service\n     * @throws If the key is not already defined\n     * @throws If the key saved in the container does not correspond to a service\n     * @throws If the function passed it not...well, a function\n     */\n    extend(key, fn) {\n        checkDefined(this, key);\n        let originalItem = this._items[key];\n        assert(isFunction(originalItem) && this._protected.has(originalItem) === false, `Identifier '${key}' does not contain a service definition`);\n        assert(isFunction(fn), `The 'new' service definition for '${key}' is not a invokable object.`);\n        this._items[key] = function(app) {\n            return fn(originalItem(app), app);\n        }\n        if (this._factories.has(originalItem)) {\n            this._factories.delete(originalItem);\n            this._factories.add(this._items[key]);\n        }\n    }\n\n    /**\n     * Uses an provider to extend the service, so it's easy to split the service and parameter definitions across the system\n     * @param {{register: function(Jimple)}} provider - The provider to be used to register services and parameters in this container\n     */\n    register(provider) {\n        provider.register(this);\n    }\n\n    /**\n     * Returns the raw value of a service or parameter. So, in the case of a service, for example, the value returned is the\n     * function used to construct the service.\n     * @param {string} key - The key of the service or parameter to return.\n     * @throws If the key does not exist in the container\n     * @return {*} The raw value of the service or parameter\n     */\n    raw(key) {\n        checkDefined(this, key);\n        return this._items[key];\n    }\n}\n\nmodule.exports = Jimple;\n","export * from './jimple';\nexport * from './factories';\nexport * from './helpers';\n","// @ts-expect-error - the idea is to have `any` and assert on export.\nimport JimpleOriginal from 'jimple';\nimport { Container as JimpleContainer } from './jimple.type';\n\nconst Jimple = JimpleOriginal as typeof JimpleContainer;\n\nexport { Jimple };\nexport type { JimpleContainer };\n","import { Jimple as JimpleMod } from '../jimplemod';\n\nexport class Jimple extends JimpleMod {\n  /**\n   * This is a version of the `get` method that doesn't throw if the key doesn't exist. It\n   * will return `undefined` instead.\n   *\n   * @param key  The key of the parameter or service to return.\n   * @returns The object related to the service or the value of the parameter\n   *          associated with the given key.\n   * @template T  The type of the returned object.\n   */\n  try<T = unknown>(key: string): T | undefined {\n    if (!this.has(key)) {\n      return undefined;\n    }\n\n    return this.get<T>(key);\n  }\n}\n/**\n * Shorthand for `new Jimple()`.\n *\n * @param args  The same parameters as the {@link Jimple} constructor.\n * @returns A new instance of {@link Jimple}.\n */\nexport const jimple = (...args: ConstructorParameters<typeof Jimple>): Jimple =>\n  new Jimple(...args);\n","import type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to create resources of an specified type. This function itself\n * doesn't have logic, but it's just in charge of creating the constraint for the resource\n * function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create a resource with a specified type of\n *          function.\n * @template ResourceFn  The type of function the resource needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (c) => {\n *     c.set('foo', 'bar');\n *   });\n *\n */\nexport const resourceFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource using the contraint defined in the factory.\n   *\n   * @param name  The name of the resource.\n   * @param key   The property key for the function.\n   * @param fn    The resource function.\n   * @returns An object with the `name` set to `true`, and the `fn` as the `key`.\n   * @template Name  The literal type of `name`, to be used in the return object.\n   * @template Key   The literal type of `key`, to be used in the return object.\n   * @template Fn    The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (c) => {\n   *     c.set('foo', 'bar');\n   *   });\n   *\n   */\n  <Name extends string, Key extends string, Fn extends ResourceFn>(\n    name: Name,\n    key: Key,\n    fn: Fn,\n  ): Resource<Name, Key, Fn> =>\n    ({\n      [name]: true,\n      [key]: fn,\n    } as Resource<Name, Key, Fn>);\n","import { resourceFactory } from './resourceFactory';\nimport type {\n  GenericFn,\n  GenericCurriedFn,\n  ResourceCreator,\n  ResourceCreatorCurriedFn,\n  ResourceCreatorHandler,\n} from './factories.types';\n/**\n * Generates a function to create resource creators of an specified type. This function\n * itself doesn't have logic, but it's just in charge of creating the constraint for the\n * resource creator function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to create \"resource creators\".\n * @template ResourceFn  The type of function the resource creator needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourceCreatorFactory<ActionFn>();\n *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n *     c.set(name, 'bar');\n *   });\n *\n */\nexport const resourceCreatorFactory =\n  <ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a new resource creator using the contraint defined in the factory.\n   *\n   * @param name       The name of the resource.\n   * @param key        The property key for the function.\n   * @param creatorFn  The curried function that returns the actual resource function.\n   * @returns A resource creator: an object that can be used as a resource, and as a\n   *          function that returns a resource.\n   * @template Name       The literal type of `name`, to be used in the return object.\n   * @template Key        The literal type of `key`, to be used in the return object.\n   * @template ResFn      The type of the resource function, the creator function needs\n   *                      to return. This is restricted by the factory constraint.\n   * @template CreatorFn  The literal type of `creatorFn`, to be used in the return\n   *                      object.\n   * @example\n   *\n   *   const myAction = factory('action', 'fn', (name = 'foo') => (c) => {\n   *     c.set(name, 'bar');\n   *   });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ResFn extends ResourceFn,\n    CreatorFn extends GenericCurriedFn<ResFn>,\n  >(\n    name: Name,\n    key: Key,\n    creatorFn: CreatorFn,\n  ): ResourceCreator<Name, Key, CreatorFn, ResourceFn> => {\n    const fnToProxy: ResourceCreatorCurriedFn<Name, Key, CreatorFn> = (...args) => {\n      const actualResource = creatorFn(...args) as ReturnType<CreatorFn>;\n      return resourceFactory<ResFn>()(name, key, actualResource);\n    };\n\n    const handler: ResourceCreatorHandler<Name, Key, CreatorFn> = {\n      name,\n      resource: null,\n      get(target, property) {\n        let result;\n        if (property === this.name) {\n          result = true;\n        } else if (property === key) {\n          if (this.resource === null) {\n            const newResource = creatorFn() as ReturnType<CreatorFn>;\n            this.resource = newResource;\n          }\n          result = this.resource;\n        } else {\n          const targetKey = property as keyof typeof target;\n          result = target[targetKey];\n        }\n\n        return result;\n      },\n      has(target, property) {\n        if (property === this.name || property === key) {\n          return true;\n        }\n\n        const targetKey = property as keyof typeof target;\n        return targetKey in target;\n      },\n    };\n\n    return new Proxy(fnToProxy, handler) as unknown as ResourceCreator<\n      Name,\n      Key,\n      CreatorFn,\n      ResourceFn\n    >;\n  };\n","import { resourceFactory } from './resourceFactory';\nimport type { GenericFn, Resource } from './factories.types';\n/**\n * Generates a function to configure a collection of resources of an specified type. This\n * function itself doesn't have logic, but it's just in charge of creating the constraint\n * for the resource name and function.\n *\n * As all the other _\"factory functions\"_, this is meant to be used as a building block\n * when extending the container.\n *\n * @returns A function that can be used to configure a collection of resources.\n * @template ResourceName  The literal type of the name the resources needs to have.\n * @template ResourceFn    The type of function the resources needs to have.\n * @example\n *\n *   type ActionFn = (c: Jimple) => void;\n *   const factory = resourcesCollectionFactory<'action', ActionFn>();\n *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n *\n */\nexport const resourcesCollectionFactory =\n  <ResourceName extends string, ResourceFn extends GenericFn>() =>\n  /**\n   * Generates a function to create a collection of resources of an specified type. A\n   * collection is a dictionary of resources, and a resource itself, and when its\n   * \"resource function\" gets called, it calls the function of every resource (with the\n   * same args it recevied).\n   *\n   * @param name  The resource name the items in the collection must have.\n   * @param key   The key property the items in the collection must have.\n   * @param fn    A custom function to process the items in the collection, when the\n   *              collection function gets called.\n   * @returns A function that can be used to create a resources collection.\n   * @template Name      The literal type of `name`, to be used in the return object.\n   * @template Key       The literal type of `key`, to be used in the return object.\n   * @template ItemKey   To capture the name of the resources in the collection.\n   * @template Items     The kind of dictionary of resources the return function will\n   *                     expect.\n   * @template CustomFn  The type of `fn`, restricted by the factory constraint.\n   * @example\n   *\n   *   const myActions = factory('action', 'fn')({ myActionA, myActionB });\n   *\n   */\n  <\n    Name extends string,\n    Key extends string,\n    ItemKey extends string,\n    Items extends Record<ItemKey, Resource<ResourceName, Key, ResourceFn>>,\n    CustomFn extends (items: Items, ...rest: Parameters<ResourceFn>) => void,\n  >(\n    name: Name,\n    key: Key,\n    fn?: CustomFn,\n  ) => {\n    const collectionResourceFactory = resourceFactory<ResourceFn>();\n    /**\n     * The actual function that recevies the items and creates the collection.\n     *\n     * @param items  A dictionary of resources for the collection.\n     * @returns A dictionary of the resources, that it's also a resource.\n     * @template ItemsParam  The literal type of `items`, to be used in the return\n     *                       object.\n     * @throws If the dictionary contains the resource name or function key as keys.\n     * @throws If one of the items doesn't have the resource function.\n     */\n    return <ItemsParam>(\n      items: ItemsParam & Items,\n    ): typeof items & Resource<Name, Key, ResourceFn> => {\n      const invalidKeys: string[] = [name, key];\n      const itemsKeys = Object.keys(items) as Array<keyof Items>;\n\n      const invalidKey = itemsKeys.some((itemKey) =>\n        invalidKeys.includes(String(itemKey)),\n      );\n      if (invalidKey) {\n        throw new Error(\n          `No item on the collection can have the keys \\`${name}\\` nor \\`${key}\\``,\n        );\n      }\n\n      const invalidItem = itemsKeys.find(\n        (itemKey) => typeof items[itemKey]?.[key] !== 'function',\n      );\n      if (invalidItem) {\n        throw new Error(\n          `The item \\`${String(\n            invalidItem,\n          )}\\` is invalid: it doesn't have a \\`${key}\\` function`,\n        );\n      }\n\n      const useFn = fn\n        ? (...args: Parameters<ResourceFn>) => fn(items, ...args)\n        : (...args: Parameters<ResourceFn>) => {\n            itemsKeys.forEach((itemK) => {\n              const item = items[itemK]!;\n              const itemFn = item[key];\n              itemFn(...args);\n            });\n          };\n\n      return {\n        ...collectionResourceFactory(name, key, useFn as ResourceFn),\n        ...items,\n      };\n    };\n  };\n","import type { Jimple } from '../jimple';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- They are dynamically extended.\ntype GenericDict = Record<any, any>;\n/**\n * A helper that reusable services can use to resolve dependencies in constructors and/or\n * providers.\n *\n * @template InjectDictionary  A dictionary of the dependencies and their types.\n * @template InjectKey         The literal type of the dictionary types.\n */\nexport class InjectHelper<\n  InjectDictionary extends GenericDict,\n  InjectKey = keyof InjectDictionary,\n> {\n  /**\n   * This method is meant to be used to validate the dependencies a service receives, and\n   * needs.\n   * It will check on the received dependencies, if a specific dependency exists, it will\n   * return it, otherwise, it will create a new instance.\n   *\n   * @param dependencies  The dependencies received by the implementation.\n   * @param key           The key of the dependency to validate.\n   * @param init          A function to create a dependency in case it doesn't exist in\n   *                      the dictionary.\n   * @returns An instance of the dependency.\n   * @template DepKey   The literal key of the dependency to validate.\n   * @template DepType  The type of the dependency, obtained from the dictionary sent\n   *                    to the constructor.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyServiceOptions = {\n   *     inject?: Partial<Dependencies>;\n   *   };\n   *   const myService = ({ inject = {} }: MyServiceOptions) => {\n   *     const dep = helper.get(inject, 'dep', () => 'default');\n   *     console.log('dep:', dep);\n   *   };\n   *\n   */\n  get<DepKey extends InjectKey, DepType = InjectDictionary[DepKey]>(\n    dependencies: Partial<InjectDictionary>,\n    key: InjectKey,\n    init: () => DepType,\n  ): DepType {\n    const existing = dependencies[key];\n    if (typeof existing !== 'undefined') {\n      return existing!;\n    }\n\n    return init();\n  }\n  /**\n   * This is meant to be used in a provider creator to resolve dependencies' names sent as\n   * options. For each dependency, the method will first check if a new name was\n   * specified, and try to get it with that name, otherwise, it will try to get it with\n   * the default name, and if it doesn't exist, it will just keep it as `undefined` and\n   * expect the service implements {@link InjectHelper.get} to ensure the dependency.\n   *\n   * @param dependencies  The dependencies needed by the service.\n   * @param container     A reference to the Jimple container.\n   * @param inject        A dictionary of dependencies names.\n   * @returns A dictionary of dependencies to send to the service.\n   * @template DepKey     The literal key of the dependencies to validate.\n   * @template Container  The type of the Jimple container.\n   * @example\n   *\n   *   type Dependencies = {\n   *     dep: string;\n   *   };\n   *   const helper = new InjectHelper<Dependencies>();\n   *\n   *   type MyProviderOptions = {\n   *     services?: {\n   *       [key in keyof Dependencies]?: string;\n   *     };\n   *   };\n   *\n   *   const myProvider = providerCreator(\n   *     ({ services = {} }: MyProviderOptions) =>\n   *       (container) => {\n   *         container.set('myService', () => {\n   *           const inject = helper.resolve(['dep'], container, services);\n   *           return myService({ inject });\n   *         });\n   *       },\n   *   );\n   *\n   */\n  resolve<DepKey extends InjectKey, Container extends Jimple>(\n    dependencies: DepKey[],\n    container: Container,\n    inject: Partial<Record<keyof InjectDictionary, string>>,\n  ): Partial<InjectDictionary> {\n    const result = dependencies.reduce<Partial<InjectDictionary>>((acc, key) => {\n      if (inject[key]) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(inject[key]!);\n        return acc;\n      }\n\n      const keyStr = key as unknown as string;\n      if (container.has(keyStr)) {\n        acc[key] = container.get<InjectDictionary[typeof key]>(keyStr);\n        return acc;\n      }\n\n      return acc;\n    }, {});\n\n    return result;\n  }\n}\n/**\n * Shorthand for `new InjectHelper()`.\n *\n * @returns A new instance of {@link InjectHelper}.\n */\nexport const injectHelper = <InjectDictionary extends GenericDict>() =>\n  new InjectHelper<InjectDictionary>();\n","import type { Jimple } from '../jimple';\nimport { resourceFactory } from '../factories';\n\nexport type ProviderName = 'provider';\nexport type ProviderKey = 'register';\n/**\n * The function the container will call when the provider is registered.\n *\n * @param container  A reference for container where the provider is being registered.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport type ProviderRegisterFn<ContainerType extends Jimple = Jimple> = (\n  container: ContainerType,\n) => void;\n/**\n * Generates a function to create providers for a specific type of container.\n *\n * @returns A function to create providers.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProvider = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourceFactory<RegisterFn>();\n  return (register: RegisterFn) => factory('provider', 'register', register);\n};\n/**\n * Creates a resource to be registered in a Jimple container.\n *\n * @example\n *\n *   export const myService = provider((c) => {\n *     c.set('myService', () => new MyService());\n *   });\n *\n */\nexport const provider = createProvider();\n/**\n * A resource that can be registered in a Jimple container.\n */\nexport type Provider = ReturnType<typeof provider>;\n","import type { Jimple } from '../jimple';\nimport { resourceCreatorFactory, type GenericCurriedFn } from '../factories';\nimport type { ProviderRegisterFn } from './provider';\n/**\n * Generates a function to create \"provider creators\" for a specific type of container.\n *\n * @returns A function to generate provider creators.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviderCreator = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  type ProviderCreatorFn = GenericCurriedFn<RegisterFn>;\n  const factory = resourceCreatorFactory<RegisterFn>();\n  return <CreatorFn extends ProviderCreatorFn>(creator: CreatorFn) =>\n    factory('provider', 'register', creator);\n};\n/**\n * Generates a \"provider creator\": a provider that can also be called as a function in\n * order to create a configured provider.\n *\n * @example\n *\n *   export const myService = providerCreator((options: Opts = {}) => (c) => {\n *     c.set('myService', () => new MyService(options));\n *   });\n *\n */\nexport const providerCreator = createProviderCreator();\n/**\n * A function that returns a provider registration function.\n */\nexport type ProviderCreatorFn = Parameters<typeof providerCreator>[0];\n","import type { Jimple } from '../jimple';\nimport { resourcesCollectionFactory } from '../factories';\nimport type { ProviderRegisterFn, ProviderName } from './provider';\n/**\n * Generates a function to create a providers collection for a specific type of container.\n *\n * @returns A function to create providers collections.\n * @template ContainerType  The type of the Jimple container (in case it gets\n *                          subclassed).\n */\nexport const createProviders = <ContainerType extends Jimple = Jimple>() => {\n  type RegisterFn = ProviderRegisterFn<ContainerType>;\n  const factory = resourcesCollectionFactory<ProviderName, RegisterFn>();\n  return factory('provider', 'register');\n};\n/**\n * Generates a collection of providers. A collection is a dictionary of providers that can\n * also be used as a provider, and when it gets registered, it will register all of the\n * providers in the collection.\n *\n * @param items  A dictionary of providers.\n * @example\n *\n * <caption>Assuming we already have two service providers...</caption>\n *\n *   export const services = providers({\n *     myServiceProvider,\n *     myOtherServiceProvider,\n *   });\n *\n */\nexport const providers = createProviders();\n"],"mappings":"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","names":["module","Jimple","provider","Jimple","JimpleOriginal","Jimple"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@homer0/jimple",
   "description": "An extended version of the Jimple lib, with extra features",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/homer0/packages.git",
@@ -23,11 +23,11 @@
     "dist/"
   ],
   "devDependencies": {
-    "jest": "^29.4.1",
+    "jest": "^29.4.3",
     "jimple": "^1.5.0",
     "ts-jest": "^29.0.5",
-    "tsup": "^6.5.0",
-    "typescript": "^4.9.4"
+    "tsup": "^6.6.3",
+    "typescript": "^4.9.5"
   },
   "engine-strict": true,
   "engines": {
@@ -43,5 +43,5 @@
     "build": "tsup src/index.ts",
     "prepublishOnly": "npm run build"
   },
-  "gitHead": "59c0f6af6901b9f4edb8d2ec36abaf11f6b0780d"
+  "gitHead": "1ed6ea29e2035f10f0dff60203b6b1d54c601dc8"
 }