typed-object-accumulator
Version:
Class capable of accumulation properties and types
160 lines • 17.8 kB
JavaScript
"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 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));
}
}
exports.ObjectAccumulator = ObjectAccumulator;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accumulator.js","sourceRoot":"","sources":["../src/accumulator.ts"],"names":[],"mappings":"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","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"]}