indusagi-coding-agent 0.1.23 → 0.1.24

package/dist/utils/data-transformer.d.ts

@@ -0,0 +1,326 @@
+/**
+ * @fileoverview Advanced data transformation utilities with immutability guarantees
+ *
+ * This module provides:
+ * - Deep merge and clone operations
+ * - Immutable object transformations
+ * - Data selection (pick, omit)
+ * - Data flattening and unflattening
+ * - Grouping and sorting utilities
+ * - Deduplication and unique operations
+ * - Value mapping and transformation
+ * - Performance-optimized operations with O(n) complexity notes
+ *
+ * @example
+ * import { deepMerge, deepClone, pick, groupBy } from './data-transformer';
+ *
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { b: { d: 3 }, e: 4 };
+ * const merged = deepMerge(obj1, obj2);
+ *
+ * @author indusagi
+ * @version 1.0.0
+ */
+/**
+ * Deep clone an object with full immutability
+ * @param obj - Object to clone
+ * @returns Deep cloned copy
+ *
+ * Performance: O(n) where n = total properties at all levels
+ * Space: O(n) for new object allocation
+ *
+ * @example
+ * const original = { a: 1, b: { c: [1, 2, 3] } };
+ * const clone = deepClone(original);
+ * clone.b.c.push(4);
+ * console.log(original.b.c); // [1, 2, 3]
+ * console.log(clone.b.c); // [1, 2, 3, 4]
+ *
+ * @example
+ * // Handle circular references gracefully
+ * const circular: any = { a: 1 };
+ * circular.self = circular;
+ * const cloned = deepClone(circular); // Creates shallow copy for circular ref
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * Deep merge multiple objects
+ * @param target - Target object
+ * @param sources - Source objects to merge
+ * @returns Merged object (new instance)
+ *
+ * Performance: O(n) for each source object
+ * Later values override earlier ones
+ * Creates new object, does not mutate originals
+ *
+ * @example
+ * const base = { api: { host: 'localhost', port: 3000 } };
+ * const prod = { api: { host: 'api.example.com' } };
+ * const merged = deepMerge(base, prod);
+ * // { api: { host: 'api.example.com', port: 3000 } }
+ *
+ * @example
+ * const config1 = { db: { user: 'root' } };
+ * const config2 = { db: { password: 'secret' } };
+ * const config3 = { api: { timeout: 5000 } };
+ * const final = deepMerge(config1, config2, config3);
+ */
+export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: T[]): T;
+/**
+ * Pick specific keys from object
+ * @param obj - Source object
+ * @param keys - Keys to pick
+ * @returns New object with only specified keys
+ *
+ * Performance: O(k) where k = number of keys to pick
+ * Immutable: creates new object
+ *
+ * @example
+ * const user = { id: 1, name: 'John', email: 'john@example.com', password: 'secret' };
+ * const safe = pick(user, ['id', 'name', 'email']);
+ * // { id: 1, name: 'John', email: 'john@example.com' }
+ *
+ * @example
+ * const data = { a: 1, b: 2, c: 3, d: 4 };
+ * const subset = pick(data, ['a', 'c']);
+ * // { a: 1, c: 3 }
+ */
+export declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Partial<T>;
+/**
+ * Omit specific keys from object
+ * @param obj - Source object
+ * @param keys - Keys to omit
+ * @returns New object without specified keys
+ *
+ * Performance: O(n) where n = total properties
+ * Immutable: creates new object
+ *
+ * @example
+ * const user = { id: 1, name: 'John', email: 'john@example.com', password: 'secret' };
+ * const safe = omit(user, ['password']);
+ * // { id: 1, name: 'John', email: 'john@example.com' }
+ *
+ * @example
+ * const config = { dev: true, test: false, prod: true, internal: 'value' };
+ * const public_ = omit(config, ['internal']);
+ */
+export declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Partial<T>;
+/**
+ * Flatten nested object to single level
+ * @param obj - Nested object
+ * @param prefix - Key prefix for nested keys
+ * @returns Flattened object
+ *
+ * Performance: O(n) where n = total nested properties
+ *
+ * @example
+ * const nested = {
+ *   user: { name: 'John', age: 30 },
+ *   settings: { theme: 'dark', lang: 'en' }
+ * };
+ * const flat = flatten(nested);
+ * // {
+ * //   'user.name': 'John',
+ * //   'user.age': 30,
+ * //   'settings.theme': 'dark',
+ * //   'settings.lang': 'en'
+ * // }
+ *
+ * @example
+ * const deep = { a: { b: { c: { d: 1 } } } };
+ * const flat = flatten(deep);
+ * // { 'a.b.c.d': 1 }
+ */
+export declare function flatten(obj: any, prefix?: string): Record<string, any>;
+/**
+ * Unflatten object from dotted keys
+ * @param obj - Flattened object
+ * @returns Nested object
+ *
+ * Performance: O(n) where n = number of keys
+ *
+ * @example
+ * const flat = {
+ *   'user.name': 'John',
+ *   'user.age': 30,
+ *   'settings.theme': 'dark'
+ * };
+ * const nested = unflatten(flat);
+ * // { user: { name: 'John', age: 30 }, settings: { theme: 'dark' } }
+ */
+export declare function unflatten(obj: Record<string, any>): any;
+/**
+ * Group array by key function
+ * @param items - Array to group
+ * @param keyFn - Function to determine grouping key
+ * @returns Object with grouped arrays
+ *
+ * Performance: O(n) where n = array length
+ *
+ * @example
+ * const users = [
+ *   { id: 1, role: 'admin' },
+ *   { id: 2, role: 'user' },
+ *   { id: 3, role: 'admin' }
+ * ];
+ * const byRole = groupBy(users, u => u.role);
+ * // { admin: [{id: 1, role: 'admin'}, {id: 3, role: 'admin'}], user: [{id: 2, role: 'user'}] }
+ *
+ * @example
+ * const words = ['apple', 'apricot', 'banana', 'blueberry'];
+ * const byFirstLetter = groupBy(words, w => w[0]);
+ * // { a: ['apple', 'apricot'], b: ['banana', 'blueberry'] }
+ */
+export declare function groupBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T, index: number) => K): Record<K, T[]>;
+/**
+ * Sort array by multiple criteria
+ * @param items - Array to sort
+ * @param compareFn - Comparison function
+ * @returns Sorted array (new instance)
+ *
+ * Performance: O(n log n) typical case
+ * Immutable: returns new array
+ *
+ * @example
+ * const users = [
+ *   { name: 'Charlie', age: 30 },
+ *   { name: 'Alice', age: 25 },
+ *   { name: 'Bob', age: 25 }
+ * ];
+ * const sorted = sortBy(users, (a, b) => {
+ *   if (a.age !== b.age) return a.age - b.age;
+ *   return a.name.localeCompare(b.name);
+ * });
+ *
+ * @example
+ * const numbers = [3, 1, 4, 1, 5, 9, 2, 6];
+ * const sorted = sortBy(numbers, (a, b) => a - b);
+ */
+export declare function sortBy<T>(items: T[], compareFn: (a: T, b: T) => number): T[];
+/**
+ * Get unique items from array
+ * @param items - Array with potential duplicates
+ * @param keyFn - Optional function to determine uniqueness
+ * @returns Array with unique items
+ *
+ * Performance: O(n) with Set, O(n log n) without
+ *
+ * @example
+ * const numbers = [1, 2, 2, 3, 3, 3, 4];
+ * const unique = uniqueBy(numbers);
+ * // [1, 2, 3, 4]
+ *
+ * @example
+ * const users = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' },
+ *   { id: 1, name: 'John' }
+ * ];
+ * const unique = uniqueBy(users, u => u.id);
+ * // [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
+ */
+export declare function uniqueBy<T, K = T>(items: T[], keyFn?: (item: T) => K): T[];
+/**
+ * Map object values to new values
+ * @param obj - Source object
+ * @param mapFn - Mapping function
+ * @returns New object with mapped values
+ *
+ * Performance: O(n) where n = number of properties
+ * Keys are preserved, only values transform
+ *
+ * @example
+ * const scores = { math: 85, english: 90, science: 88 };
+ * const percentages = mapValues(scores, v => `${v}%`);
+ * // { math: '85%', english: '90%', science: '88%' }
+ *
+ * @example
+ * const prices = { apple: 0.5, banana: 0.3 };
+ * const taxed = mapValues(prices, v => v * 1.1);
+ * // { apple: 0.55, banana: 0.33 }
+ */
+export declare function mapValues<T extends Record<string, any>, V>(obj: T, mapFn: (value: T[keyof T], key: string) => V): Record<keyof T, V>;
+/**
+ * Transform object keys
+ * @param obj - Source object
+ * @param transformFn - Key transformation function
+ * @returns New object with transformed keys
+ *
+ * @example
+ * const obj = { firstName: 'John', lastName: 'Doe' };
+ * const snake = transformKeys(obj, k => k.replace(/([A-Z])/g, '_$1').toLowerCase());
+ * // { first_name: 'John', last_name: 'Doe' }
+ */
+export declare function transformKeys<T extends Record<string, any>>(obj: T, transformFn: (key: string) => string): Record<string, any>;
+/**
+ * Filter object by predicate
+ * @param obj - Source object
+ * @param predicate - Filter function
+ * @returns New object with filtered entries
+ *
+ * Performance: O(n) where n = number of properties
+ *
+ * @example
+ * const config = { debug: true, prod: false, test: true, verbose: false };
+ * const enabled = filterObject(config, (v) => v === true);
+ * // { debug: true, test: true }
+ */
+export declare function filterObject<T extends Record<string, any>>(obj: T, predicate: (value: T[keyof T], key: string) => boolean): Partial<T>;
+/**
+ * Invert object keys and values
+ * @param obj - Object to invert
+ * @returns Inverted object
+ *
+ * @example
+ * const mapping = { en: 'English', es: 'Spanish', fr: 'French' };
+ * const inverted = invertObject(mapping);
+ * // { English: 'en', Spanish: 'es', French: 'fr' }
+ */
+export declare function invertObject(obj: Record<string, string>): Record<string, string>;
+/**
+ * Check if value is empty (null, undefined, empty string, empty array, empty object)
+ * @param value - Value to check
+ * @returns True if empty
+ *
+ * @example
+ * isEmpty(null); // true
+ * isEmpty(undefined); // true
+ * isEmpty(''); // true
+ * isEmpty([]); // true
+ * isEmpty({}); // true
+ * isEmpty(0); // false
+ */
+export declare function isEmpty(value: any): boolean;
+/**
+ * Get value from object using dot notation path
+ * @param obj - Source object
+ * @param path - Dot notation path (e.g., 'user.profile.age')
+ * @param defaultValue - Default if not found
+ * @returns Value at path or default
+ *
+ * Performance: O(k) where k = path depth
+ *
+ * @example
+ * const user = { profile: { address: { city: 'New York' } } };
+ * const city = getPath(user, 'profile.address.city');
+ * // 'New York'
+ *
+ * @example
+ * const city = getPath(user, 'profile.country', 'Unknown');
+ * // 'Unknown'
+ */
+export declare function getPath<T = any>(obj: any, path: string, defaultValue?: T): T | undefined;
+/**
+ * Set value in object using dot notation path
+ * @param obj - Target object
+ * @param path - Dot notation path
+ * @param value - Value to set
+ * @returns New object with value set (immutable)
+ *
+ * @example
+ * const user = { profile: { name: 'John' } };
+ * const updated = setPath(user, 'profile.age', 30);
+ * // { profile: { name: 'John', age: 30 } }
+ */
+export declare function setPath(obj: any, path: string, value: any): any;
+//# sourceMappingURL=data-transformer.d.ts.map

package/dist/utils/data-transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-transformer.d.ts","sourceRoot":"","sources":["../../src/utils/data-transformer.ts"],"names":[],"mappings":"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"}