indusagi-coding-agent 0.1.59 → 0.1.60

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

@@ -1,391 +0,0 @@
-/**
- * @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, seen?: WeakMap<WeakKey, any>): 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 arrays to a single level (with optional depth)
- * @param arr - Array to flatten
- * @param depth - Maximum depth to flatten (default: Infinity)
- * @returns Flattened array
- *
- * Performance: O(n) where n = total elements at all levels
- *
- * @example
- * flatten([1, [2, 3], [4, [5, 6]]]) // [1, 2, 3, 4, 5, 6]
- * flatten([1, [2, [3, [4]]]], 1) // [1, 2, [3, [4]]]
- * flatten([1, [2, [3, [4]]]], 2) // [1, 2, 3, [4]]
- *
- * @example
- * // Empty arrays
- * flatten([]) // []
- * flatten([[], []]) // []
- */
-export declare function flatten<T>(arr: T[], depth?: number): T[];
-/**
- * Flatten nested object to single level (dot notation)
- * @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 = flattenObject(nested);
- * // {
- * //   'user.name': 'John',
- * //   'user.age': 30,
- * //   'settings.theme': 'dark',
- * //   'settings.lang': 'en'
- * // }
- *
- * @example
- * const deep = { a: { b: { c: { d: 1 } } } };
- * const flat = flattenObject(deep);
- * // { 'a.b.c.d': 1 }
- */
-export declare function flattenObject(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 extract comparison key
- * @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>(items: T[], keyFn?: (item: T) => any): T[];
-/**
- * Get unique items from array (alias for uniqueBy)
- * @param items - Array with potential duplicates
- * @param keyFn - Optional function to extract comparison key
- * @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 = unique(numbers);
- * // [1, 2, 3, 4]
- *
- * @example
- * const users = [
- *   { id: 1, name: 'John' },
- *   { id: 2, name: 'Jane' },
- *   { id: 1, name: 'John' }
- * ];
- * const unique = unique(users, u => u.id);
- * // [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
- */
-export declare function unique<T>(items: T[], keyFn?: (item: T) => any): T[];
-/**
- * Create an object keyed by the result of a key function
- * @param items - Array to transform
- * @param keyFn - Function to extract key from each item
- * @returns Object with keys mapped to items
- *
- * Performance: O(n)
- *
- * @example
- * const users = [
- *   { id: 1, name: 'John' },
- *   { id: 2, name: 'Jane' }
- * ];
- * const byId = keyBy(users, u => u.id);
- * // { 1: { id: 1, name: 'John' }, 2: { id: 2, name: 'Jane' } }
- *
- * @example
- * // Last wins for duplicates
- * const items = [{ id: 1, v: 'a' }, { id: 1, v: 'b' }];
- * const byId = keyBy(items, i => i.id);
- * // { 1: { id: 1, v: 'b' } }
- */
-export declare function keyBy<T>(items: T[], keyFn: (item: T) => string | number | symbol): Record<string | number | symbol, 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/helpers/data-transformer.d.ts.map

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