typed-object-accumulator
Version:
Class capable of accumulation properties and types
182 lines (177 loc) • 20.4 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["typed-object-accumulator"] = {}));
})(this, (function (exports) { 'use strict';
/**
* @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 T - value type
* @template K - The key type, must be a key of this
* @param {K} key - The key of the value to retrieve
* @returns The value associated with the key
*/
get(key) {
if (!(key in this))
throw new Error(`Key ${key} does not exist in accumulator. Available keys: ${this.keys().join(", ")}`);
return this[key];
}
/**
* @description Retrieves a value from the accumulator by its key
* @summary Gets a value from the accumulated object using a type-safe key
* @param {string} key - The key of the value to retrieve
* @param {any} value - The key of the value to retrieve
*/
put(key, value) {
return this.accumulate({ [key]: value });
}
/**
* @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));
}
}
/**
* @module typed-object-accumulator
* @description A TypeScript library for accumulating objects with type safety
* @summary This module provides utilities for dynamically accumulating object properties while maintaining type information. It exports the {@link ObjectAccumulator} class and version information.
*/
/**
* @description Represents the current version of the typed-object-accumulator module
* @summary The actual version number is replaced during the build process with the package version
* @const VERSION
* @type {string}
* @memberOf module:typed-object-accumulator
*/
const VERSION = "0.1.4";
exports.ObjectAccumulator = ObjectAccumulator;
exports.VERSION = VERSION;
}));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"typed-object-accumulator.cjs","sources":["../src/accumulator.ts","../src/index.ts"],"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 T - value type\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 The value associated with the key\n   */\n  get<K extends keyof T>(key: K): T[K] {\n    if (!(key in this))\n      throw new Error(\n        `Key ${key as string} does not exist in accumulator. Available keys: ${this.keys().join(\n          \", \"\n        )}`\n      );\n    return (this as any)[key as K] as T[K];\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   * @param {string} key - The key of the value to retrieve\n   * @param {any} value - The key of the value to retrieve\n   */\n  put(key: string, value: any) {\n    return this.accumulate({ [key]: value });\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","/**\n * @module typed-object-accumulator\n * @description A TypeScript library for accumulating objects with type safety\n * @summary This module provides utilities for dynamically accumulating object properties while maintaining type information. It exports the {@link ObjectAccumulator} class and version information.\n */\n\nexport * from \"./accumulator\";\n\n/**\n * @description Represents the current version of the typed-object-accumulator module\n * @summary The actual version number is replaced during the build process with the package version\n * @const VERSION\n * @type {string}\n * @memberOf module:typed-object-accumulator\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}