@decaf-ts/utils 0.2.8 → 0.2.9

package/lib/esm/utils/accumulator.js

@@ -0,0 +1,144 @@
+/**
+ * @class ObjectAccumulator
+ * @template T - The type of the accumulated object, extends object
+ * @description A class that accumulates objects and provides type-safe access to their properties.
+ * It allows for dynamic addition of properties while maintaining type information.
+ * @summary Accumulates objects and maintains type information for accumulated properties
+ * @memberOf utils
+ */
+export class ObjectAccumulator {
+    constructor() {
+        Object.defineProperty(this, "__size", {
+            value: 0,
+            writable: true,
+            configurable: false,
+            enumerable: false,
+        });
+    }
+    /**
+     * @protected
+     * @description Expands the accumulator with properties from a new object
+     * @summary Adds new properties to the accumulator
+     * @template V - The type of the object being expanded
+     * @param {V} value - The object to expand with
+     * @returns {void}
+     */
+    expand(value) {
+        Object.entries(value).forEach(([k, v]) => {
+            Object.defineProperty(this, k, {
+                get: () => v,
+                set: (val) => {
+                    v = val;
+                },
+                configurable: true,
+                enumerable: true,
+            });
+        });
+    }
+    /**
+     * @description Accumulates a new object into the accumulator
+     * @summary Adds properties from a new object to the accumulator, maintaining type information
+     * @template V - The type of the object being accumulated
+     * @param {V} value - The object to accumulate
+     * @returns A new ObjectAccumulator instance with updated type information
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Accumulator
+     *   participant O as Object
+     *   A->>O: Get entries
+     *   loop For each entry
+     *     A->>A: Define property
+     *   end
+     *   A->>A: Update size
+     *   A->>A: Return updated accumulator
+     */
+    accumulate(value) {
+        this.expand(value);
+        this.__size = this.__size + Object.keys(value).length;
+        return this;
+    }
+    /**
+     * @description Retrieves a value from the accumulator by its key
+     * @summary Gets a value from the accumulated object using a type-safe key
+     * @template K - The key type, must be a key of this
+     * @param {K} key - The key of the value to retrieve
+     * @returns {any | undefined} The value associated with the key, or undefined if not found
+     */
+    get(key) {
+        return this[key];
+    }
+    /**
+     * @description Checks if a key exists in the accumulator
+     * @summary Determines whether the accumulator contains a specific key
+     * @param {string} key - The key to check for existence
+     * @returns {boolean} True if the key exists, false otherwise
+     */
+    has(key) {
+        return !!this[key];
+    }
+    /**
+     * @description Removes a key-value pair from the accumulator
+     * @summary Deletes a property from the accumulated object
+     * @param {string} key - The key of the property to remove
+     * @returns {} The accumulator instance with the specified property removed
+     */
+    remove(key) {
+        if (!(key in this))
+            return this;
+        delete this[key];
+        this.__size--;
+        return this;
+    }
+    /**
+     * @description Retrieves all keys from the accumulator
+     * @summary Gets an array of all accumulated property keys
+     * @returns {string[]} An array of keys as strings
+     */
+    keys() {
+        return Object.keys(this);
+    }
+    /**
+     * @description Retrieves all values from the accumulator
+     * @summary Gets an array of all accumulated property values
+     * @returns An array of values
+     */
+    values() {
+        return Object.values(this);
+    }
+    /**
+     * @description Gets the number of key-value pairs in the accumulator
+     * @summary Returns the count of accumulated properties
+     * @returns {number} The number of key-value pairs
+     */
+    size() {
+        return this.__size;
+    }
+    /**
+     * @description Clears all accumulated key-value pairs
+     * @summary Removes all properties from the accumulator and returns a new empty instance
+     * @returns {ObjectAccumulator<never>} A new empty ObjectAccumulator instance
+     */
+    clear() {
+        return new ObjectAccumulator();
+    }
+    /**
+     * @description Executes a callback for each key-value pair in the accumulator
+     * @summary Iterates over all accumulated properties, calling a function for each
+     * @param {function(any, string, number): void} callback - The function to execute for each entry
+     * @returns {void}
+     */
+    forEach(callback) {
+        Object.entries(this).forEach(([key, value], i) => callback(value, key, i));
+    }
+    /**
+     * @description Creates a new array with the results of calling a provided function on every element in the accumulator
+     * @summary Maps each accumulated property to a new value using a callback function
+     * @template R - The type of the mapped values
+     * @param {function(any, string,number): R} callback - Function that produces an element of the new array
+     * @returns {R[]} A new array with each element being the result of the callback function
+     */
+    map(callback) {
+        return Object.entries(this).map(([key, value], i) => callback(value, key, i));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accumulator.js","sourceRoot":"","sources":["../../../src/utils/accumulator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAO,iBAAiB;IAQ5B;QACE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE;YACpC,KAAK,EAAE,CAAC;YACR,QAAQ,EAAE,IAAI;YACd,YAAY,EAAE,KAAK;YACnB,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACO,MAAM,CAAmB,KAAQ;QACzC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;YACvC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE;gBAC7B,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;gBACZ,GAAG,EAAE,CAAC,GAAe,EAAE,EAAE;oBACvB,CAAC,GAAG,GAAG,CAAC;gBACV,CAAC;gBACD,YAAY,EAAE,IAAI;gBAClB,UAAU,EAAE,IAAI;aACjB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAmB,KAAQ;QACnC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;QACtD,OAAO,IAAmD,CAAC;IAC7D,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAuB,GAAM;QAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,CAAC,CAAC,IAAI,CAAC,GAAiB,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CACJ,GAAwB;QAIxB,IAAI,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAEhC,OAAO,IAAI,CAAC,GAAiB,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,OAAO,IACoC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,MAAM;QACJ,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACH,KAAK;QACH,OAAO,IAAI,iBAAiB,EAAE,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACH,OAAO,CACL,QAAuE;QAEvE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,CAC/C,QAAQ,CAAC,KAAK,EAAE,GAAiB,EAAE,CAAC,CAAC,CACtC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CACD,QAAoE;QAEpE,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,CAClD,QAAQ,CAAC,KAAK,EAAE,GAAiB,EAAE,CAAC,CAAC,CACtC,CAAC;IACJ,CAAC;CACF","sourcesContent":["/**\n * @class ObjectAccumulator\n * @template T - The type of the accumulated object, extends object\n * @description A class that accumulates objects and provides type-safe access to their properties.\n * It allows for dynamic addition of properties while maintaining type information.\n * @summary Accumulates objects and maintains type information for accumulated properties\n * @memberOf utils\n */\nexport class ObjectAccumulator<T extends object> {\n  /**\n   * @private\n   * @description The size of the accumulated object\n   * @type {number}\n   */\n  private __size!: number;\n\n  constructor() {\n    Object.defineProperty(this, \"__size\", {\n      value: 0,\n      writable: true,\n      configurable: false,\n      enumerable: false,\n    });\n  }\n\n  /**\n   * @protected\n   * @description Expands the accumulator with properties from a new object\n   * @summary Adds new properties to the accumulator\n   * @template V - The type of the object being expanded\n   * @param {V} value - The object to expand with\n   * @returns {void}\n   */\n  protected expand<V extends object>(value: V): void {\n    Object.entries(value).forEach(([k, v]) => {\n      Object.defineProperty(this, k, {\n        get: () => v,\n        set: (val: V[keyof V]) => {\n          v = val;\n        },\n        configurable: true,\n        enumerable: true,\n      });\n    });\n  }\n\n  /**\n   * @description Accumulates a new object into the accumulator\n   * @summary Adds properties from a new object to the accumulator, maintaining type information\n   * @template V - The type of the object being accumulated\n   * @param {V} value - The object to accumulate\n   * @returns A new ObjectAccumulator instance with updated type information\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Accumulator\n   *   participant O as Object\n   *   A->>O: Get entries\n   *   loop For each entry\n   *     A->>A: Define property\n   *   end\n   *   A->>A: Update size\n   *   A->>A: Return updated accumulator\n   */\n  accumulate<V extends object>(value: V): T & V & ObjectAccumulator<T & V> {\n    this.expand(value);\n    this.__size = this.__size + Object.keys(value).length;\n    return this as unknown as T & V & ObjectAccumulator<T & V>;\n  }\n\n  /**\n   * @description Retrieves a value from the accumulator by its key\n   * @summary Gets a value from the accumulated object using a type-safe key\n   * @template K - The key type, must be a key of this\n   * @param {K} key - The key of the value to retrieve\n   * @returns {any | undefined} The value associated with the key, or undefined if not found\n   */\n  get<K extends keyof this>(key: K): this[K] | undefined {\n    return this[key];\n  }\n\n  /**\n   * @description Checks if a key exists in the accumulator\n   * @summary Determines whether the accumulator contains a specific key\n   * @param {string} key - The key to check for existence\n   * @returns {boolean} True if the key exists, false otherwise\n   */\n  has(key: string): boolean {\n    return !!this[key as keyof this];\n  }\n\n  /**\n   * @description Removes a key-value pair from the accumulator\n   * @summary Deletes a property from the accumulated object\n   * @param {string} key - The key of the property to remove\n   * @returns {} The accumulator instance with the specified property removed\n   */\n  remove(\n    key: keyof this | string\n  ):\n    | (Omit<this, typeof key> & ObjectAccumulator<Omit<this, typeof key>>)\n    | this {\n    if (!(key in this)) return this;\n\n    delete this[key as keyof this];\n    this.__size--;\n    return this as unknown as Omit<this, typeof key> &\n      ObjectAccumulator<Omit<this, typeof key>>;\n  }\n\n  /**\n   * @description Retrieves all keys from the accumulator\n   * @summary Gets an array of all accumulated property keys\n   * @returns {string[]} An array of keys as strings\n   */\n  keys(): string[] {\n    return Object.keys(this);\n  }\n\n  /**\n   * @description Retrieves all values from the accumulator\n   * @summary Gets an array of all accumulated property values\n   * @returns An array of values\n   */\n  values(): T[keyof T][] {\n    return Object.values(this);\n  }\n\n  /**\n   * @description Gets the number of key-value pairs in the accumulator\n   * @summary Returns the count of accumulated properties\n   * @returns {number} The number of key-value pairs\n   */\n  size(): number {\n    return this.__size;\n  }\n\n  /**\n   * @description Clears all accumulated key-value pairs\n   * @summary Removes all properties from the accumulator and returns a new empty instance\n   * @returns {ObjectAccumulator<never>} A new empty ObjectAccumulator instance\n   */\n  clear(): ObjectAccumulator<never> {\n    return new ObjectAccumulator();\n  }\n\n  /**\n   * @description Executes a callback for each key-value pair in the accumulator\n   * @summary Iterates over all accumulated properties, calling a function for each\n   * @param {function(any, string, number): void} callback - The function to execute for each entry\n   * @returns {void}\n   */\n  forEach(\n    callback: (value: this[keyof this], key: keyof this, i: number) => void\n  ): void {\n    Object.entries(this).forEach(([key, value], i) =>\n      callback(value, key as keyof this, i)\n    );\n  }\n\n  /**\n   * @description Creates a new array with the results of calling a provided function on every element in the accumulator\n   * @summary Maps each accumulated property to a new value using a callback function\n   * @template R - The type of the mapped values\n   * @param {function(any, string,number): R} callback - Function that produces an element of the new array\n   * @returns {R[]} A new array with each element being the result of the callback function\n   */\n  map<R>(\n    callback: (value: this[keyof this], key: keyof this, i: number) => R\n  ): R[] {\n    return Object.entries(this).map(([key, value], i) =>\n      callback(value, key as keyof this, i)\n    );\n  }\n}\n"]}

package/lib/esm/utils/environment.d.ts

@@ -1,5 +1,5 @@
+import { ObjectAccumulator } from "./accumulator";
 import { EnvironmentFactory } from "./types";
-import { ObjectAccumulator } from "typed-object-accumulator";
 /**
  * @class Environment
  * @extends {ObjectAccumulator<T>}

package/lib/esm/utils/environment.js

@@ -1,6 +1,6 @@
 import { toENVFormat } from "./text";
+import { ObjectAccumulator } from "./accumulator";
 import { isBrowser } from "./web";
-import { ObjectAccumulator } from "typed-object-accumulator";
 /**
  * @class Environment
  * @extends {ObjectAccumulator<T>}
@@ -87,4 +87,4 @@ export class Environment extends ObjectAccumulator {
             .map((k) => (toEnv ? toENVFormat(k) : k));
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.cjs

@@ -48,10 +48,10 @@ __exportStar(require("./writers/index.cjs"), exports);
  * @description Represents the current version of the module.
  * @summary This constant stores the version number of the @asdasdasd/utils module.
  * The actual version number is replaced during the build process,
- * with the placeholder "0.2.7" being substituted with the current version.
+ * with the placeholder "0.2.9" being substituted with the current version.
  *
  * @const VERSION
  * @memberOf module:@decaf-ts/utils
  */
-exports.VERSION = "0.2.7";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3Q0FBc0I7QUFDdEIsMENBQXdCO0FBQ3hCLDJDQUF5QjtBQUN6QiwwQ0FBd0I7QUFDeEIsNENBQTBCO0FBRTFCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXVCRztBQUVIOzs7Ozs7OztHQVFHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY2xpXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pbnB1dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vb3V0cHV0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vd3JpdGVyc1wiO1xuXG4vKipcbiAqIEBtb2R1bGUgQGRlY2FmLXRzL3V0aWxzXG4gKiBAZGVzY3JpcHRpb25cbiAqIFRoaXMgbW9kdWxlIHNlcnZlcyBhIGxpZ2h0IHZlcnNpb24gb2YgRGVjYWYgQ0xJIHRvb2wsIHByb3ZpZGluZyBhIGNvbXByZWhlbnNpdmUgc2V0IG9mIHV0aWxpdGllc1xuICogYW5kIGZ1bmN0aW9uYWxpdGllcyBmb3IgY29tbWFuZC1saW5lIGludGVyZmFjZSBvcGVyYXRpb25zLiBJdCBlbmNvbXBhc3NlcyBzZXZlcmFsIGtleSBjb21wb25lbnRzOlxuICpcbiAqIDEuIElucHV0IEhhbmRsaW5nOiBNYW5hZ2VzIHVzZXIgaW5wdXQgYW5kIGNvbW1hbmQtbGluZSBhcmd1bWVudHMgcHJvY2Vzc2luZy5cbiAqIDIuIFV0aWxpdHkgRnVuY3Rpb25zOiBPZmZlcnMgYSBjb2xsZWN0aW9uIG9mIGhlbHBlciBmdW5jdGlvbnMgYW5kIGNvbnN0YW50cyBmb3IgdmFyaW91cyBvcGVyYXRpb25zLlxuICogMy4gVHlwZSBEZWZpbml0aW9uczogRGVmaW5lcyBjdXN0b20gdHlwZXMgYW5kIGludGVyZmFjZXMgdXNlZCB0aHJvdWdob3V0IHRoZSBtb2R1bGUuXG4gKiA0LiBPdXRwdXQgTWFuYWdlbWVudDogUHJvdmlkZXMgZGlmZmVyZW50IG91dHB1dCB3cml0aW5nIHN0cmF0ZWdpZXMgZm9yIGZsZXhpYmxlIGNvbnNvbGUgb3V0cHV0IGhhbmRsaW5nLlxuICpcbiAqIFRoZSBtb2R1bGUgaXMgZGVzaWduZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY3JlYXRpb24gb2Ygcm9idXN0IENMSSBhcHBsaWNhdGlvbnMgYnkgb2ZmZXJpbmc6XG4gKiAtIFN0YW5kYXJkaXplZCBpbnB1dCBwYXJzaW5nIGFuZCB2YWxpZGF0aW9uXG4gKiAtIENvbnNpc3RlbnQgb3V0cHV0IGZvcm1hdHRpbmcgYW5kIGhhbmRsaW5nXG4gKiAtIFJldXNhYmxlIHV0aWxpdHkgZnVuY3Rpb25zIGZvciBjb21tb24gQ0xJIHRhc2tzXG4gKiAtIEV4dGVuc2libGUgYXJjaGl0ZWN0dXJlIGZvciBhZGRpbmcgbmV3IGNvbW1hbmRzIGFuZCBmZWF0dXJlc1xuICpcbiAqIEl0IHN1cHBvcnRzIHZhcmlvdXMgb3V0cHV0IG1vZGVzLCBpbmNsdWRpbmcgc3RhbmRhcmQgY29uc29sZSBvdXRwdXQgYW5kIHJlZ3VsYXIgZXhwcmVzc2lvbi1iYXNlZCBvdXRwdXQsXG4gKiBhbGxvd2luZyBmb3IgdmVyc2F0aWxlIGRhdGEgcHJlc2VudGF0aW9uIGFuZCBwcm9jZXNzaW5nLiBUaGUgbW9kdWxhciBzdHJ1Y3R1cmUgZW5hYmxlcyBlYXN5IG1haW50ZW5hbmNlXG4gKiBhbmQgZXh0ZW5zaW9uIG9mIHRoZSBDTEkgZnVuY3Rpb25hbGl0eS5cbiAqXG4gKiBUaGlzIG1vZHVsZSBpcyBwYXJ0aWN1bGFybHkgdXNlZnVsIGZvciBkZXZlbG9wZXJzIGJ1aWxkaW5nIGNvbXBsZXggY29tbWFuZC1saW5lIHRvb2xzIHRoYXQgcmVxdWlyZVxuICogc3RydWN0dXJlZCBpbnB1dCBoYW5kbGluZywgZmxleGlibGUgb3V0cHV0IGZvcm1hdHRpbmcsIGFuZCBhIHJpY2ggc2V0IG9mIHV0aWxpdHkgZnVuY3Rpb25zLlxuICovXG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIFJlcHJlc2VudHMgdGhlIGN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgbW9kdWxlLlxuICogQHN1bW1hcnkgVGhpcyBjb25zdGFudCBzdG9yZXMgdGhlIHZlcnNpb24gbnVtYmVyIG9mIHRoZSBAYXNkYXNkYXNkL3V0aWxzIG1vZHVsZS5cbiAqIFRoZSBhY3R1YWwgdmVyc2lvbiBudW1iZXIgaXMgcmVwbGFjZWQgZHVyaW5nIHRoZSBidWlsZCBwcm9jZXNzLFxuICogd2l0aCB0aGUgcGxhY2Vob2xkZXIgXCIjI1ZFUlNJT04jI1wiIGJlaW5nIHN1YnN0aXR1dGVkIHdpdGggdGhlIGN1cnJlbnQgdmVyc2lvbi5cbiAqXG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTpAZGVjYWYtdHMvdXRpbHNcbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIiMjVkVSU0lPTiMjXCI7XG4iXX0=
+exports.VERSION = "0.2.9";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -31,9 +31,9 @@ export * from "./writers";
  * @description Represents the current version of the module.
  * @summary This constant stores the version number of the @asdasdasd/utils module.
  * The actual version number is replaced during the build process,
- * with the placeholder "0.2.7" being substituted with the current version.
+ * with the placeholder "0.2.9" being substituted with the current version.
  *
  * @const VERSION
  * @memberOf module:@decaf-ts/utils
  */
-export declare const VERSION = "0.2.7";
+export declare const VERSION = "0.2.9";

package/lib/input/index.cjs

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./input.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5wdXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF3QjtBQUN4QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2lucHV0JztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5wdXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUF3QjtBQUN4Qiw4Q0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2lucHV0JztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19

package/lib/output/index.cjs

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./common.cjs"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3V0cHV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwyQ0FBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb21tb25cIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3V0cHV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwrQ0FBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb21tb25cIjtcbiJdfQ==

package/lib/utils/accumulator.cjs

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectAccumulator = void 0;
+/**
+ * @class ObjectAccumulator
+ * @template T - The type of the accumulated object, extends object
+ * @description A class that accumulates objects and provides type-safe access to their properties.
+ * It allows for dynamic addition of properties while maintaining type information.
+ * @summary Accumulates objects and maintains type information for accumulated properties
+ * @memberOf utils
+ */
+class ObjectAccumulator {
+    constructor() {
+        Object.defineProperty(this, "__size", {
+            value: 0,
+            writable: true,
+            configurable: false,
+            enumerable: false,
+        });
+    }
+    /**
+     * @protected
+     * @description Expands the accumulator with properties from a new object
+     * @summary Adds new properties to the accumulator
+     * @template V - The type of the object being expanded
+     * @param {V} value - The object to expand with
+     * @returns {void}
+     */
+    expand(value) {
+        Object.entries(value).forEach(([k, v]) => {
+            Object.defineProperty(this, k, {
+                get: () => v,
+                set: (val) => {
+                    v = val;
+                },
+                configurable: true,
+                enumerable: true,
+            });
+        });
+    }
+    /**
+     * @description Accumulates a new object into the accumulator
+     * @summary Adds properties from a new object to the accumulator, maintaining type information
+     * @template V - The type of the object being accumulated
+     * @param {V} value - The object to accumulate
+     * @returns A new ObjectAccumulator instance with updated type information
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Accumulator
+     *   participant O as Object
+     *   A->>O: Get entries
+     *   loop For each entry
+     *     A->>A: Define property
+     *   end
+     *   A->>A: Update size
+     *   A->>A: Return updated accumulator
+     */
+    accumulate(value) {
+        this.expand(value);
+        this.__size = this.__size + Object.keys(value).length;
+        return this;
+    }
+    /**
+     * @description Retrieves a value from the accumulator by its key
+     * @summary Gets a value from the accumulated object using a type-safe key
+     * @template K - The key type, must be a key of this
+     * @param {K} key - The key of the value to retrieve
+     * @returns {any | undefined} The value associated with the key, or undefined if not found
+     */
+    get(key) {
+        return this[key];
+    }
+    /**
+     * @description Checks if a key exists in the accumulator
+     * @summary Determines whether the accumulator contains a specific key
+     * @param {string} key - The key to check for existence
+     * @returns {boolean} True if the key exists, false otherwise
+     */
+    has(key) {
+        return !!this[key];
+    }
+    /**
+     * @description Removes a key-value pair from the accumulator
+     * @summary Deletes a property from the accumulated object
+     * @param {string} key - The key of the property to remove
+     * @returns {} The accumulator instance with the specified property removed
+     */
+    remove(key) {
+        if (!(key in this))
+            return this;
+        delete this[key];
+        this.__size--;
+        return this;
+    }
+    /**
+     * @description Retrieves all keys from the accumulator
+     * @summary Gets an array of all accumulated property keys
+     * @returns {string[]} An array of keys as strings
+     */
+    keys() {
+        return Object.keys(this);
+    }
+    /**
+     * @description Retrieves all values from the accumulator
+     * @summary Gets an array of all accumulated property values
+     * @returns An array of values
+     */
+    values() {
+        return Object.values(this);
+    }
+    /**
+     * @description Gets the number of key-value pairs in the accumulator
+     * @summary Returns the count of accumulated properties
+     * @returns {number} The number of key-value pairs
+     */
+    size() {
+        return this.__size;
+    }
+    /**
+     * @description Clears all accumulated key-value pairs
+     * @summary Removes all properties from the accumulator and returns a new empty instance
+     * @returns {ObjectAccumulator<never>} A new empty ObjectAccumulator instance
+     */
+    clear() {
+        return new ObjectAccumulator();
+    }
+    /**
+     * @description Executes a callback for each key-value pair in the accumulator
+     * @summary Iterates over all accumulated properties, calling a function for each
+     * @param {function(any, string, number): void} callback - The function to execute for each entry
+     * @returns {void}
+     */
+    forEach(callback) {
+        Object.entries(this).forEach(([key, value], i) => callback(value, key, i));
+    }
+    /**
+     * @description Creates a new array with the results of calling a provided function on every element in the accumulator
+     * @summary Maps each accumulated property to a new value using a callback function
+     * @template R - The type of the mapped values
+     * @param {function(any, string,number): R} callback - Function that produces an element of the new array
+     * @returns {R[]} A new array with each element being the result of the callback function
+     */
+    map(callback) {
+        return Object.entries(this).map(([key, value], i) => callback(value, key, i));
+    }
+}
+exports.ObjectAccumulator = ObjectAccumulator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accumulator.js","sourceRoot":"","sources":["../../src/utils/accumulator.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,MAAa,iBAAiB;IAQ5B;QACE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE;YACpC,KAAK,EAAE,CAAC;YACR,QAAQ,EAAE,IAAI;YACd,YAAY,EAAE,KAAK;YACnB,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACO,MAAM,CAAmB,KAAQ;QACzC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;YACvC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE;gBAC7B,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;gBACZ,GAAG,EAAE,CAAC,GAAe,EAAE,EAAE;oBACvB,CAAC,GAAG,GAAG,CAAC;gBACV,CAAC;gBACD,YAAY,EAAE,IAAI;gBAClB,UAAU,EAAE,IAAI;aACjB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAmB,KAAQ;QACnC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;QACtD,OAAO,IAAmD,CAAC;IAC7D,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAuB,GAAM;QAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,CAAC,CAAC,IAAI,CAAC,GAAiB,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CACJ,GAAwB;QAIxB,IAAI,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAEhC,OAAO,IAAI,CAAC,GAAiB,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,OAAO,IACoC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,MAAM;QACJ,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACH,KAAK;QACH,OAAO,IAAI,iBAAiB,EAAE,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACH,OAAO,CACL,QAAuE;QAEvE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,CAC/C,QAAQ,CAAC,KAAK,EAAE,GAAiB,EAAE,CAAC,CAAC,CACtC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CACD,QAAoE;QAEpE,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,CAClD,QAAQ,CAAC,KAAK,EAAE,GAAiB,EAAE,CAAC,CAAC,CACtC,CAAC;IACJ,CAAC;CACF;AArKD,8CAqKC","sourcesContent":["/**\n * @class ObjectAccumulator\n * @template T - The type of the accumulated object, extends object\n * @description A class that accumulates objects and provides type-safe access to their properties.\n * It allows for dynamic addition of properties while maintaining type information.\n * @summary Accumulates objects and maintains type information for accumulated properties\n * @memberOf utils\n */\nexport class ObjectAccumulator<T extends object> {\n  /**\n   * @private\n   * @description The size of the accumulated object\n   * @type {number}\n   */\n  private __size!: number;\n\n  constructor() {\n    Object.defineProperty(this, \"__size\", {\n      value: 0,\n      writable: true,\n      configurable: false,\n      enumerable: false,\n    });\n  }\n\n  /**\n   * @protected\n   * @description Expands the accumulator with properties from a new object\n   * @summary Adds new properties to the accumulator\n   * @template V - The type of the object being expanded\n   * @param {V} value - The object to expand with\n   * @returns {void}\n   */\n  protected expand<V extends object>(value: V): void {\n    Object.entries(value).forEach(([k, v]) => {\n      Object.defineProperty(this, k, {\n        get: () => v,\n        set: (val: V[keyof V]) => {\n          v = val;\n        },\n        configurable: true,\n        enumerable: true,\n      });\n    });\n  }\n\n  /**\n   * @description Accumulates a new object into the accumulator\n   * @summary Adds properties from a new object to the accumulator, maintaining type information\n   * @template V - The type of the object being accumulated\n   * @param {V} value - The object to accumulate\n   * @returns A new ObjectAccumulator instance with updated type information\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Accumulator\n   *   participant O as Object\n   *   A->>O: Get entries\n   *   loop For each entry\n   *     A->>A: Define property\n   *   end\n   *   A->>A: Update size\n   *   A->>A: Return updated accumulator\n   */\n  accumulate<V extends object>(value: V): T & V & ObjectAccumulator<T & V> {\n    this.expand(value);\n    this.__size = this.__size + Object.keys(value).length;\n    return this as unknown as T & V & ObjectAccumulator<T & V>;\n  }\n\n  /**\n   * @description Retrieves a value from the accumulator by its key\n   * @summary Gets a value from the accumulated object using a type-safe key\n   * @template K - The key type, must be a key of this\n   * @param {K} key - The key of the value to retrieve\n   * @returns {any | undefined} The value associated with the key, or undefined if not found\n   */\n  get<K extends keyof this>(key: K): this[K] | undefined {\n    return this[key];\n  }\n\n  /**\n   * @description Checks if a key exists in the accumulator\n   * @summary Determines whether the accumulator contains a specific key\n   * @param {string} key - The key to check for existence\n   * @returns {boolean} True if the key exists, false otherwise\n   */\n  has(key: string): boolean {\n    return !!this[key as keyof this];\n  }\n\n  /**\n   * @description Removes a key-value pair from the accumulator\n   * @summary Deletes a property from the accumulated object\n   * @param {string} key - The key of the property to remove\n   * @returns {} The accumulator instance with the specified property removed\n   */\n  remove(\n    key: keyof this | string\n  ):\n    | (Omit<this, typeof key> & ObjectAccumulator<Omit<this, typeof key>>)\n    | this {\n    if (!(key in this)) return this;\n\n    delete this[key as keyof this];\n    this.__size--;\n    return this as unknown as Omit<this, typeof key> &\n      ObjectAccumulator<Omit<this, typeof key>>;\n  }\n\n  /**\n   * @description Retrieves all keys from the accumulator\n   * @summary Gets an array of all accumulated property keys\n   * @returns {string[]} An array of keys as strings\n   */\n  keys(): string[] {\n    return Object.keys(this);\n  }\n\n  /**\n   * @description Retrieves all values from the accumulator\n   * @summary Gets an array of all accumulated property values\n   * @returns An array of values\n   */\n  values(): T[keyof T][] {\n    return Object.values(this);\n  }\n\n  /**\n   * @description Gets the number of key-value pairs in the accumulator\n   * @summary Returns the count of accumulated properties\n   * @returns {number} The number of key-value pairs\n   */\n  size(): number {\n    return this.__size;\n  }\n\n  /**\n   * @description Clears all accumulated key-value pairs\n   * @summary Removes all properties from the accumulator and returns a new empty instance\n   * @returns {ObjectAccumulator<never>} A new empty ObjectAccumulator instance\n   */\n  clear(): ObjectAccumulator<never> {\n    return new ObjectAccumulator();\n  }\n\n  /**\n   * @description Executes a callback for each key-value pair in the accumulator\n   * @summary Iterates over all accumulated properties, calling a function for each\n   * @param {function(any, string, number): void} callback - The function to execute for each entry\n   * @returns {void}\n   */\n  forEach(\n    callback: (value: this[keyof this], key: keyof this, i: number) => void\n  ): void {\n    Object.entries(this).forEach(([key, value], i) =>\n      callback(value, key as keyof this, i)\n    );\n  }\n\n  /**\n   * @description Creates a new array with the results of calling a provided function on every element in the accumulator\n   * @summary Maps each accumulated property to a new value using a callback function\n   * @template R - The type of the mapped values\n   * @param {function(any, string,number): R} callback - Function that produces an element of the new array\n   * @returns {R[]} A new array with each element being the result of the callback function\n   */\n  map<R>(\n    callback: (value: this[keyof this], key: keyof this, i: number) => R\n  ): R[] {\n    return Object.entries(this).map(([key, value], i) =>\n      callback(value, key as keyof this, i)\n    );\n  }\n}\n"]}