ngx-com 0.0.1 → 0.0.4

package/fesm2022/ngx-com-utils.mjs

@@ -0,0 +1,601 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+/**
+ * Merges and deduplicates CSS class names using clsx and tailwind-merge.
+ * Tailwind-merge ensures conflicting utility classes are resolved correctly.
+ *
+ * @param inputs - Class values to merge (strings, arrays, objects, or falsy values)
+ * @returns A single string of merged, deduplicated class names
+ *
+ * @example
+ * ```ts
+ * mergeClasses('px-2 py-1', 'px-4'); // 'py-1 px-4'
+ * mergeClasses('text-sm', condition && 'text-lg'); // 'text-lg' if condition is true
+ * ```
+ */
+function mergeClasses(...inputs) {
+    return twMerge(clsx(inputs));
+}
+
+/**
+ * Creates a debounced version of the provided function that delays invoking
+ * until after the specified wait time has elapsed since the last call.
+ *
+ * The debounced function includes `cancel()` to abort pending calls,
+ * `flush()` to immediately execute pending calls, and `pending()` to check status.
+ *
+ * @template T - The type of the function to debounce.
+ * @param fn - The function to debounce.
+ * @param optionsOrWait - Wait time in ms or options object.
+ * @returns The debounced function with control methods.
+ *
+ * @example
+ * // Basic usage with default 300ms delay
+ * const debouncedSearch = debounce((query: string) => {
+ *   console.log('Searching for:', query);
+ * });
+ * debouncedSearch('hello'); // Logs after 300ms if no subsequent calls
+ *
+ * @example
+ * // With custom wait time
+ * const debouncedSave = debounce(
+ *   (data: { id: number; value: string }) => saveToServer(data),
+ *   500
+ * );
+ *
+ * @example
+ * // With options object and leading edge execution
+ * const debouncedClick = debounce(
+ *   () => handleClick(),
+ *   { wait: 200, leading: true }
+ * );
+ *
+ * @example
+ * // Cleanup in Angular component
+ * export class SearchComponent {
+ *   private debouncedSearch = debounce((q: string) => this.search(q), 300);
+ *
+ *   ngOnDestroy(): void {
+ *     this.debouncedSearch.cancel();
+ *   }
+ * }
+ */
+function debounce(fn, optionsOrWait = 300) {
+    const options = typeof optionsOrWait === 'number' ? { wait: optionsOrWait } : optionsOrWait;
+    const wait = options.wait ?? 300;
+    const leading = options.leading ?? false;
+    let timerId = null;
+    let pendingArgs = null;
+    let leadingInvoked = false;
+    const invoke = () => {
+        if (pendingArgs !== null) {
+            fn(...pendingArgs);
+            pendingArgs = null;
+        }
+        leadingInvoked = false;
+    };
+    const debounced = (...args) => {
+        pendingArgs = args;
+        if (leading && !leadingInvoked) {
+            leadingInvoked = true;
+            invoke();
+        }
+        if (timerId !== null) {
+            clearTimeout(timerId);
+        }
+        timerId = setTimeout(() => {
+            timerId = null;
+            if (!leading || pendingArgs !== null) {
+                invoke();
+            }
+        }, wait);
+    };
+    debounced.cancel = () => {
+        if (timerId !== null) {
+            clearTimeout(timerId);
+            timerId = null;
+        }
+        pendingArgs = null;
+        leadingInvoked = false;
+    };
+    debounced.flush = () => {
+        if (timerId !== null) {
+            clearTimeout(timerId);
+            timerId = null;
+            invoke();
+        }
+    };
+    debounced.pending = () => timerId !== null;
+    return debounced;
+}
+
+/**
+ * Creates a throttled version of the provided function that only invokes
+ * at most once per the specified wait period.
+ *
+ * The function is invoked on the leading edge (immediately on first call)
+ * and then at most once per wait period for subsequent calls.
+ *
+ * @template T - The type of the function to throttle.
+ * @param fn - The function to throttle.
+ * @param wait - The minimum time between invocations in milliseconds.
+ * @returns The throttled function with a cancel method.
+ *
+ * @example
+ * // Basic usage - scroll handler
+ * const throttledScroll = throttle(() => {
+ *   console.log('Scroll position:', window.scrollY);
+ * }, 100);
+ * window.addEventListener('scroll', throttledScroll);
+ *
+ * @example
+ * // With cleanup
+ * export class ScrollComponent {
+ *   private throttledHandler = throttle((e: Event) => this.handleScroll(e), 100);
+ *
+ *   ngOnDestroy(): void {
+ *     this.throttledHandler.cancel();
+ *   }
+ * }
+ */
+function throttle(fn, wait) {
+    let lastCallTime = 0;
+    let timerId = null;
+    let pendingArgs = null;
+    const invoke = (args) => {
+        lastCallTime = Date.now();
+        fn(...args);
+    };
+    const throttled = (...args) => {
+        const now = Date.now();
+        const remaining = wait - (now - lastCallTime);
+        if (remaining <= 0) {
+            if (timerId !== null) {
+                clearTimeout(timerId);
+                timerId = null;
+            }
+            invoke(args);
+        }
+        else {
+            pendingArgs = args;
+            if (timerId === null) {
+                timerId = setTimeout(() => {
+                    timerId = null;
+                    if (pendingArgs !== null) {
+                        invoke(pendingArgs);
+                        pendingArgs = null;
+                    }
+                }, remaining);
+            }
+        }
+    };
+    throttled.cancel = () => {
+        if (timerId !== null) {
+            clearTimeout(timerId);
+            timerId = null;
+        }
+        pendingArgs = null;
+    };
+    return throttled;
+}
+
+/**
+ * Retries an async function with configurable attempts, delay, and backoff.
+ *
+ * @template T - The return type of the async function.
+ * @param fn - The async function to retry.
+ * @param options - Retry configuration.
+ * @returns The result of the successful call.
+ * @throws The last error if all attempts fail.
+ *
+ * @example
+ * // Basic retry with 3 attempts
+ * const data = await retry(
+ *   () => fetch('/api/data').then(r => r.json()),
+ *   { attempts: 3, delay: 1000 }
+ * );
+ *
+ * @example
+ * // With exponential backoff
+ * const result = await retry(
+ *   () => unreliableApiCall(),
+ *   { attempts: 5, delay: 100, backoff: 2 } // delays: 100, 200, 400, 800, 1600
+ * );
+ *
+ * @example
+ * // With conditional retry
+ * const result = await retry(
+ *   () => apiCall(),
+ *   {
+ *     attempts: 3,
+ *     delay: 500,
+ *     shouldRetry: (err) => err instanceof NetworkError
+ *   }
+ * );
+ */
+async function retry(fn, options) {
+    const { attempts, delay, backoff = 1, shouldRetry } = options;
+    let lastError;
+    let currentDelay = delay;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (shouldRetry && !shouldRetry(error)) {
+                throw error;
+            }
+            if (attempt < attempts) {
+                await new Promise(resolve => setTimeout(resolve, currentDelay));
+                currentDelay *= backoff;
+            }
+        }
+    }
+    throw lastError;
+}
+
+/**
+ * Creates a new object with only the specified keys from the source object.
+ *
+ * @template T - The type of the source object.
+ * @template K - The keys to pick.
+ * @param obj - The source object.
+ * @param keys - The keys to pick from the object.
+ * @returns A new object containing only the specified keys.
+ *
+ * @example
+ * const user = { id: 1, name: 'John', email: 'john@example.com', age: 30 };
+ * pick(user, ['id', 'name']); // { id: 1, name: 'John' }
+ *
+ * @example
+ * const config = { host: 'localhost', port: 3000, debug: true };
+ * pick(config, ['host', 'port']); // { host: 'localhost', port: 3000 }
+ */
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+
+/**
+ * Creates a new object with the specified keys omitted from the source object.
+ *
+ * @template T - The type of the source object.
+ * @template K - The keys to omit.
+ * @param obj - The source object.
+ * @param keys - The keys to omit from the object.
+ * @returns A new object without the specified keys.
+ *
+ * @example
+ * const user = { id: 1, name: 'John', password: 'secret', email: 'john@example.com' };
+ * omit(user, ['password']); // { id: 1, name: 'John', email: 'john@example.com' }
+ *
+ * @example
+ * const config = { host: 'localhost', port: 3000, debug: true };
+ * omit(config, ['debug']); // { host: 'localhost', port: 3000 }
+ */
+function omit(obj, keys) {
+    const result = { ...obj };
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
+}
+
+/**
+ * Creates a deep clone of a value, handling objects, arrays, Date, and RegExp.
+ * Note: Does not handle circular references, functions, or special objects like Map, Set.
+ * For complex cloning needs, consider using `structuredClone()`.
+ *
+ * @template T - The type of the value to clone.
+ * @param value - The value to deep clone.
+ * @returns A deep clone of the value.
+ *
+ * @example
+ * const original = { a: 1, b: { c: 2, d: [3, 4] } };
+ * const cloned = deepClone(original);
+ * cloned.b.c = 5;
+ * console.log(original.b.c); // 2 (unchanged)
+ *
+ * @example
+ * const arr = [{ id: 1 }, { id: 2 }];
+ * const clonedArr = deepClone(arr);
+ * clonedArr[0].id = 99;
+ * console.log(arr[0].id); // 1 (unchanged)
+ */
+function deepClone(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => deepClone(item));
+    }
+    // At this point, value is guaranteed to be a plain object
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = deepClone(value[key]);
+    }
+    return result;
+}
+
+/**
+ * Checks if a value is a plain object (not null, not an array).
+ *
+ * @param value - The value to check.
+ * @returns `true` if value is a plain object; otherwise, `false`.
+ *
+ * @example
+ * isPlainObject({ a: 1 }); // true
+ * isPlainObject([1, 2]); // false
+ * isPlainObject(null); // false
+ */
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Deep merges multiple source objects into a new object.
+ * Later sources override earlier ones. Arrays are replaced, not merged.
+ *
+ * @template T - The type of the resulting object.
+ * @param sources - The source objects to merge.
+ * @returns A new deeply merged object.
+ *
+ * @example
+ * const defaults = { theme: { color: 'blue', size: 'md' }, debug: false };
+ * const userConfig = { theme: { color: 'red' }, debug: true };
+ * deepMerge(defaults, userConfig);
+ * // { theme: { color: 'red', size: 'md' }, debug: true }
+ *
+ * @example
+ * const a = { arr: [1, 2], nested: { x: 1 } };
+ * const b = { arr: [3, 4], nested: { y: 2 } };
+ * deepMerge(a, b);
+ * // { arr: [3, 4], nested: { x: 1, y: 2 } } - arrays are replaced
+ */
+function deepMerge(...sources) {
+    const result = {};
+    for (const source of sources) {
+        if (typeof source !== 'object' || source === null) {
+            continue;
+        }
+        for (const key of Object.keys(source)) {
+            const sourceValue = source[key];
+            const resultValue = result[key];
+            if (Array.isArray(sourceValue)) {
+                result[key] = deepClone(sourceValue);
+            }
+            else if (isPlainObject(sourceValue) && isPlainObject(resultValue)) {
+                result[key] = deepMerge(resultValue, sourceValue);
+            }
+            else if (isPlainObject(sourceValue)) {
+                result[key] = deepClone(sourceValue);
+            }
+            else {
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * Performs a deep equality comparison between two values.
+ * Handles primitives, objects, arrays, Date, and RegExp.
+ *
+ * @template T - The type of values to compare.
+ * @param a - The first value.
+ * @param b - The second value.
+ * @returns `true` if values are deeply equal; otherwise, `false`.
+ *
+ * @example
+ * deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true
+ * deepEqual({ a: 1 }, { a: 2 }); // false
+ * deepEqual([1, [2, 3]], [1, [2, 3]]); // true
+ * deepEqual([1, 2], [1, 2, 3]); // false
+ * deepEqual(new Date('2024-01-01'), new Date('2024-01-01')); // true
+ */
+function deepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a === null || b === null) {
+        return a === b;
+    }
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    if (typeof a !== 'object') {
+        return a === b;
+    }
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (Array.isArray(a) !== Array.isArray(b)) {
+        return false;
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        for (const key of keysA) {
+            if (!Object.prototype.hasOwnProperty.call(b, key)) {
+                return false;
+            }
+            if (!deepEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Resolves a nested path in an object, returning the value at the specified path.
+ *
+ * This function splits the provided `path` into keys and iterates through the object to access the
+ * corresponding value at each key. If any part of the path is undefined or if the path leads to a non-object,
+ * it returns `undefined`.
+ *
+ * @template T - The type of the object.
+ * @template P - The dot-separated string path type.
+ * @param obj - The object to resolve the path within.
+ * @param path - The dot-separated string representing the path to the value.
+ * @returns The value at the resolved path, or `undefined` if any part of the path is invalid.
+ *
+ * @example
+ * const obj = { user: { profile: { name: 'John Doe' } } };
+ * const result = resolvePath(obj, 'user.profile.name');
+ * console.log(result); // 'John Doe'
+ *
+ * @example
+ * const result2 = resolvePath(obj, 'user.address.city');
+ * console.log(result2); // undefined
+ */
+function resolvePath(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys) {
+        if (current && typeof current === 'object' && key in current) {
+            current = current[key];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+
+/**
+ * Splits an array into chunks of the specified size.
+ *
+ * @template T - The type of array elements.
+ * @param array - The array to split.
+ * @param size - The size of each chunk (must be positive).
+ * @returns An array of chunks.
+ *
+ * @example
+ * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
+ * chunk([1, 2, 3, 4], 2); // [[1, 2], [3, 4]]
+ * chunk([1, 2, 3], 5); // [[1, 2, 3]]
+ * chunk([], 2); // []
+ */
+function chunk(array, size) {
+    if (size <= 0) {
+        throw new Error('Chunk size must be a positive number');
+    }
+    const result = [];
+    for (let i = 0; i < array.length; i += size) {
+        result.push(array.slice(i, i + size));
+    }
+    return result;
+}
+
+/**
+ * Splits an array into two groups based on a predicate function.
+ * The first array contains elements that satisfy the predicate,
+ * the second contains elements that don't.
+ *
+ * @template T - The type of array elements.
+ * @param array - The array to partition.
+ * @param predicate - The function to test each element.
+ * @returns A tuple of [truthy, falsy] arrays.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5, 6];
+ * partition(numbers, n => n % 2 === 0); // [[2, 4, 6], [1, 3, 5]]
+ *
+ * @example
+ * const users = [
+ *   { name: 'Alice', active: true },
+ *   { name: 'Bob', active: false },
+ *   { name: 'Charlie', active: true }
+ * ];
+ * partition(users, u => u.active);
+ * // [[{ name: 'Alice', active: true }, { name: 'Charlie', active: true }], [{ name: 'Bob', active: false }]]
+ */
+function partition(array, predicate) {
+    const truthy = [];
+    const falsy = [];
+    for (const item of array) {
+        if (predicate(item)) {
+            truthy.push(item);
+        }
+        else {
+            falsy.push(item);
+        }
+    }
+    return [truthy, falsy];
+}
+
+/**
+ * Groups an array of items based on a provided predicate function.
+ *
+ * @template K - The type of keys produced by the predicate, typically a string, number, or symbol.
+ * @template V - The type of items in the collection.
+ * @param collection - The array of items to be grouped.
+ * @param predicate - A function that takes an item and returns a key by which to group the item.
+ * @returns An object where each key is a group identifier produced by the predicate,
+ * and the value is an array of items belonging to that group.
+ *
+ * @example
+ * // Group an array of people by their age
+ * const people = [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 25 }, { name: 'Charlie', age: 30 }];
+ * const groupedByAge = groupBy(people, person => person.age);
+ * // Output:
+ * // {
+ * //   25: [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 25 }],
+ * //   30: [{ name: 'Charlie', age: 30 }]
+ * // }
+ */
+function groupBy(collection, predicate) {
+    return collection.reduce((groups, item) => {
+        const groupKey = predicate(item);
+        if (!groups[groupKey]) {
+            groups[groupKey] = [];
+        }
+        groups[groupKey].push(item);
+        return groups;
+    }, {});
+}
+
+/**
+ * ngx-com/utils
+ * Utility function exports for ngx-com library
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { chunk, debounce, deepClone, deepEqual, deepMerge, groupBy, isPlainObject, mergeClasses, omit, partition, pick, resolvePath, retry, throttle };
+//# sourceMappingURL=ngx-com-utils.mjs.map

package/fesm2022/ngx-com-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngx-com-utils.mjs","sources":["../../../projects/com/utils/src/merge-classes.ts","../../../projects/com/utils/src/debounce.ts","../../../projects/com/utils/src/throttle.ts","../../../projects/com/utils/src/retry.ts","../../../projects/com/utils/src/pick.ts","../../../projects/com/utils/src/omit.ts","../../../projects/com/utils/src/deep-clone.ts","../../../projects/com/utils/src/is-plain-object.ts","../../../projects/com/utils/src/deep-merge.ts","../../../projects/com/utils/src/deep-equal.ts","../../../projects/com/utils/src/resolve-path.ts","../../../projects/com/utils/src/chunk.ts","../../../projects/com/utils/src/partition.ts","../../../projects/com/utils/src/group-by.ts","../../../projects/com/utils/src/index.ts","../../../projects/com/utils/src/ngx-com-utils.ts"],"sourcesContent":["import { type ClassValue, clsx } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\n/**\n * Merges and deduplicates CSS class names using clsx and tailwind-merge.\n * Tailwind-merge ensures conflicting utility classes are resolved correctly.\n *\n * @param inputs - Class values to merge (strings, arrays, objects, or falsy values)\n * @returns A single string of merged, deduplicated class names\n *\n * @example\n * ```ts\n * mergeClasses('px-2 py-1', 'px-4'); // 'py-1 px-4'\n * mergeClasses('text-sm', condition && 'text-lg'); // 'text-lg' if condition is true\n * ```\n */\nexport function mergeClasses(...inputs: ClassValue[]): string {\n  return twMerge(clsx(inputs));\n}\n","/**\n * A debounced function wrapper with cancel and flush capabilities.\n *\n * @template T - The type of the original function.\n */\nexport interface DebouncedFn<T extends (...args: never[]) => void> {\n  /**\n   * Calls the debounced function. The actual execution is delayed until\n   * the specified wait time has passed without another call.\n   */\n  (...args: Parameters<T>): void;\n\n  /**\n   * Cancels any pending debounced call.\n   * Useful for cleanup in component destruction or effect cleanup.\n   */\n  cancel(): void;\n\n  /**\n   * Immediately executes the pending debounced call if one exists.\n   * Does nothing if no call is pending.\n   */\n  flush(): void;\n\n  /**\n   * Returns whether there is a pending debounced call.\n   */\n  pending(): boolean;\n}\n\n/**\n * Configuration options for the debounce function.\n */\nexport interface DebounceOptions {\n  /**\n   * The number of milliseconds to delay execution.\n   * @default 300\n   */\n  readonly wait?: number;\n\n  /**\n   * If `true`, the function is invoked on the leading edge of the timeout\n   * instead of the trailing edge.\n   * @default false\n   */\n  readonly leading?: boolean;\n}\n\n/**\n * Creates a debounced version of the provided function that delays invoking\n * until after the specified wait time has elapsed since the last call.\n *\n * The debounced function includes `cancel()` to abort pending calls,\n * `flush()` to immediately execute pending calls, and `pending()` to check status.\n *\n * @template T - The type of the function to debounce.\n * @param fn - The function to debounce.\n * @param optionsOrWait - Wait time in ms or options object.\n * @returns The debounced function with control methods.\n *\n * @example\n * // Basic usage with default 300ms delay\n * const debouncedSearch = debounce((query: string) => {\n *   console.log('Searching for:', query);\n * });\n * debouncedSearch('hello'); // Logs after 300ms if no subsequent calls\n *\n * @example\n * // With custom wait time\n * const debouncedSave = debounce(\n *   (data: { id: number; value: string }) => saveToServer(data),\n *   500\n * );\n *\n * @example\n * // With options object and leading edge execution\n * const debouncedClick = debounce(\n *   () => handleClick(),\n *   { wait: 200, leading: true }\n * );\n *\n * @example\n * // Cleanup in Angular component\n * export class SearchComponent {\n *   private debouncedSearch = debounce((q: string) => this.search(q), 300);\n *\n *   ngOnDestroy(): void {\n *     this.debouncedSearch.cancel();\n *   }\n * }\n */\nexport function debounce<T extends (...args: never[]) => void>(\n  fn: T,\n  optionsOrWait: number | DebounceOptions = 300,\n): DebouncedFn<T> {\n  const options: DebounceOptions =\n    typeof optionsOrWait === 'number' ? { wait: optionsOrWait } : optionsOrWait;\n\n  const wait = options.wait ?? 300;\n  const leading = options.leading ?? false;\n\n  let timerId: ReturnType<typeof setTimeout> | null = null;\n  let pendingArgs: Parameters<T> | null = null;\n  let leadingInvoked = false;\n\n  const invoke = (): void => {\n    if (pendingArgs !== null) {\n      fn(...pendingArgs);\n      pendingArgs = null;\n    }\n    leadingInvoked = false;\n  };\n\n  const debounced = (...args: Parameters<T>): void => {\n    pendingArgs = args;\n\n    if (leading && !leadingInvoked) {\n      leadingInvoked = true;\n      invoke();\n    }\n\n    if (timerId !== null) {\n      clearTimeout(timerId);\n    }\n\n    timerId = setTimeout(() => {\n      timerId = null;\n      if (!leading || pendingArgs !== null) {\n        invoke();\n      }\n    }, wait);\n  };\n\n  debounced.cancel = (): void => {\n    if (timerId !== null) {\n      clearTimeout(timerId);\n      timerId = null;\n    }\n    pendingArgs = null;\n    leadingInvoked = false;\n  };\n\n  debounced.flush = (): void => {\n    if (timerId !== null) {\n      clearTimeout(timerId);\n      timerId = null;\n      invoke();\n    }\n  };\n\n  debounced.pending = (): boolean => timerId !== null;\n\n  return debounced;\n}\n","/**\n * A throttled function wrapper with cancel capability.\n *\n * @template T - The type of the original function.\n */\nexport interface ThrottledFn<T extends (...args: never[]) => void> {\n  /**\n   * Calls the throttled function. Execution is rate-limited to at most\n   * once per the specified wait period.\n   */\n  (...args: Parameters<T>): void;\n\n  /**\n   * Cancels any pending throttled call.\n   * Useful for cleanup in component destruction.\n   */\n  cancel(): void;\n}\n\n/**\n * Creates a throttled version of the provided function that only invokes\n * at most once per the specified wait period.\n *\n * The function is invoked on the leading edge (immediately on first call)\n * and then at most once per wait period for subsequent calls.\n *\n * @template T - The type of the function to throttle.\n * @param fn - The function to throttle.\n * @param wait - The minimum time between invocations in milliseconds.\n * @returns The throttled function with a cancel method.\n *\n * @example\n * // Basic usage - scroll handler\n * const throttledScroll = throttle(() => {\n *   console.log('Scroll position:', window.scrollY);\n * }, 100);\n * window.addEventListener('scroll', throttledScroll);\n *\n * @example\n * // With cleanup\n * export class ScrollComponent {\n *   private throttledHandler = throttle((e: Event) => this.handleScroll(e), 100);\n *\n *   ngOnDestroy(): void {\n *     this.throttledHandler.cancel();\n *   }\n * }\n */\nexport function throttle<T extends (...args: never[]) => void>(\n  fn: T,\n  wait: number,\n): ThrottledFn<T> {\n  let lastCallTime = 0;\n  let timerId: ReturnType<typeof setTimeout> | null = null;\n  let pendingArgs: Parameters<T> | null = null;\n\n  const invoke = (args: Parameters<T>): void => {\n    lastCallTime = Date.now();\n    fn(...args);\n  };\n\n  const throttled = (...args: Parameters<T>): void => {\n    const now = Date.now();\n    const remaining = wait - (now - lastCallTime);\n\n    if (remaining <= 0) {\n      if (timerId !== null) {\n        clearTimeout(timerId);\n        timerId = null;\n      }\n      invoke(args);\n    } else {\n      pendingArgs = args;\n      if (timerId === null) {\n        timerId = setTimeout(() => {\n          timerId = null;\n          if (pendingArgs !== null) {\n            invoke(pendingArgs);\n            pendingArgs = null;\n          }\n        }, remaining);\n      }\n    }\n  };\n\n  throttled.cancel = (): void => {\n    if (timerId !== null) {\n      clearTimeout(timerId);\n      timerId = null;\n    }\n    pendingArgs = null;\n  };\n\n  return throttled;\n}\n","/**\n * Configuration options for the retry function.\n */\nexport interface RetryOptions {\n  /**\n   * Maximum number of retry attempts.\n   */\n  readonly attempts: number;\n\n  /**\n   * Delay between retries in milliseconds.\n   */\n  readonly delay: number;\n\n  /**\n   * Multiplier for exponential backoff (optional).\n   * Each retry delay is multiplied by this factor.\n   * @default 1\n   */\n  readonly backoff?: number;\n\n  /**\n   * Optional predicate to determine if an error should trigger a retry.\n   * @param error - The error that occurred.\n   * @returns `true` to retry, `false` to fail immediately.\n   */\n  readonly shouldRetry?: (error: unknown) => boolean;\n}\n\n/**\n * Retries an async function with configurable attempts, delay, and backoff.\n *\n * @template T - The return type of the async function.\n * @param fn - The async function to retry.\n * @param options - Retry configuration.\n * @returns The result of the successful call.\n * @throws The last error if all attempts fail.\n *\n * @example\n * // Basic retry with 3 attempts\n * const data = await retry(\n *   () => fetch('/api/data').then(r => r.json()),\n *   { attempts: 3, delay: 1000 }\n * );\n *\n * @example\n * // With exponential backoff\n * const result = await retry(\n *   () => unreliableApiCall(),\n *   { attempts: 5, delay: 100, backoff: 2 } // delays: 100, 200, 400, 800, 1600\n * );\n *\n * @example\n * // With conditional retry\n * const result = await retry(\n *   () => apiCall(),\n *   {\n *     attempts: 3,\n *     delay: 500,\n *     shouldRetry: (err) => err instanceof NetworkError\n *   }\n * );\n */\nexport async function retry<T>(fn: () => Promise<T>, options: RetryOptions): Promise<T> {\n  const { attempts, delay, backoff = 1, shouldRetry } = options;\n\n  let lastError: unknown;\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= attempts; attempt++) {\n    try {\n      return await fn();\n    } catch (error) {\n      lastError = error;\n\n      if (shouldRetry && !shouldRetry(error)) {\n        throw error;\n      }\n\n      if (attempt < attempts) {\n        await new Promise(resolve => setTimeout(resolve, currentDelay));\n        currentDelay *= backoff;\n      }\n    }\n  }\n\n  throw lastError;\n}\n","/**\n * Creates a new object with only the specified keys from the source object.\n *\n * @template T - The type of the source object.\n * @template K - The keys to pick.\n * @param obj - The source object.\n * @param keys - The keys to pick from the object.\n * @returns A new object containing only the specified keys.\n *\n * @example\n * const user = { id: 1, name: 'John', email: 'john@example.com', age: 30 };\n * pick(user, ['id', 'name']); // { id: 1, name: 'John' }\n *\n * @example\n * const config = { host: 'localhost', port: 3000, debug: true };\n * pick(config, ['host', 'port']); // { host: 'localhost', port: 3000 }\n */\nexport function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n  const result = {} as Pick<T, K>;\n  for (const key of keys) {\n    if (key in obj) {\n      result[key] = obj[key];\n    }\n  }\n  return result;\n}\n","/**\n * Creates a new object with the specified keys omitted from the source object.\n *\n * @template T - The type of the source object.\n * @template K - The keys to omit.\n * @param obj - The source object.\n * @param keys - The keys to omit from the object.\n * @returns A new object without the specified keys.\n *\n * @example\n * const user = { id: 1, name: 'John', password: 'secret', email: 'john@example.com' };\n * omit(user, ['password']); // { id: 1, name: 'John', email: 'john@example.com' }\n *\n * @example\n * const config = { host: 'localhost', port: 3000, debug: true };\n * omit(config, ['debug']); // { host: 'localhost', port: 3000 }\n */\nexport function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n  const result = { ...obj };\n  for (const key of keys) {\n    delete result[key];\n  }\n  return result as Omit<T, K>;\n}\n","/**\n * Creates a deep clone of a value, handling objects, arrays, Date, and RegExp.\n * Note: Does not handle circular references, functions, or special objects like Map, Set.\n * For complex cloning needs, consider using `structuredClone()`.\n *\n * @template T - The type of the value to clone.\n * @param value - The value to deep clone.\n * @returns A deep clone of the value.\n *\n * @example\n * const original = { a: 1, b: { c: 2, d: [3, 4] } };\n * const cloned = deepClone(original);\n * cloned.b.c = 5;\n * console.log(original.b.c); // 2 (unchanged)\n *\n * @example\n * const arr = [{ id: 1 }, { id: 2 }];\n * const clonedArr = deepClone(arr);\n * clonedArr[0].id = 99;\n * console.log(arr[0].id); // 1 (unchanged)\n */\nexport function deepClone<T>(value: T): T {\n  if (value === null || typeof value !== 'object') {\n    return value;\n  }\n\n  if (value instanceof Date) {\n    return new Date(value.getTime()) as T;\n  }\n\n  if (value instanceof RegExp) {\n    return new RegExp(value.source, value.flags) as T;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map(item => deepClone(item)) as T;\n  }\n\n  // At this point, value is guaranteed to be a plain object\n  const result: Record<string, unknown> = {};\n  for (const key of Object.keys(value)) {\n    result[key] = deepClone((value as Record<string, unknown>)[key]);\n  }\n  return result as T;\n}\n","/**\n * Checks if a value is a plain object (not null, not an array).\n *\n * @param value - The value to check.\n * @returns `true` if value is a plain object; otherwise, `false`.\n *\n * @example\n * isPlainObject({ a: 1 }); // true\n * isPlainObject([1, 2]); // false\n * isPlainObject(null); // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n","import { deepClone } from './deep-clone';\nimport { isPlainObject } from './is-plain-object';\n\n/**\n * Deep merges multiple source objects into a new object.\n * Later sources override earlier ones. Arrays are replaced, not merged.\n *\n * @template T - The type of the resulting object.\n * @param sources - The source objects to merge.\n * @returns A new deeply merged object.\n *\n * @example\n * const defaults = { theme: { color: 'blue', size: 'md' }, debug: false };\n * const userConfig = { theme: { color: 'red' }, debug: true };\n * deepMerge(defaults, userConfig);\n * // { theme: { color: 'red', size: 'md' }, debug: true }\n *\n * @example\n * const a = { arr: [1, 2], nested: { x: 1 } };\n * const b = { arr: [3, 4], nested: { y: 2 } };\n * deepMerge(a, b);\n * // { arr: [3, 4], nested: { x: 1, y: 2 } } - arrays are replaced\n */\nexport function deepMerge<T extends object>(...sources: Partial<T>[]): T {\n  const result: Record<string, unknown> = {};\n\n  for (const source of sources) {\n    if (typeof source !== 'object' || source === null) {\n      continue;\n    }\n\n    for (const key of Object.keys(source)) {\n      const sourceValue = (source as Record<string, unknown>)[key];\n      const resultValue = result[key];\n\n      if (Array.isArray(sourceValue)) {\n        result[key] = deepClone(sourceValue);\n      } else if (isPlainObject(sourceValue) && isPlainObject(resultValue)) {\n        result[key] = deepMerge(\n          resultValue as Record<string, unknown>,\n          sourceValue as Record<string, unknown>,\n        );\n      } else if (isPlainObject(sourceValue)) {\n        result[key] = deepClone(sourceValue);\n      } else {\n        result[key] = sourceValue;\n      }\n    }\n  }\n\n  return result as T;\n}\n","import { isPlainObject } from './is-plain-object';\n\n/**\n * Performs a deep equality comparison between two values.\n * Handles primitives, objects, arrays, Date, and RegExp.\n *\n * @template T - The type of values to compare.\n * @param a - The first value.\n * @param b - The second value.\n * @returns `true` if values are deeply equal; otherwise, `false`.\n *\n * @example\n * deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true\n * deepEqual({ a: 1 }, { a: 2 }); // false\n * deepEqual([1, [2, 3]], [1, [2, 3]]); // true\n * deepEqual([1, 2], [1, 2, 3]); // false\n * deepEqual(new Date('2024-01-01'), new Date('2024-01-01')); // true\n */\nexport function deepEqual<T>(a: T, b: T): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (a === null || b === null) {\n    return a === b;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  if (typeof a !== 'object') {\n    return a === b;\n  }\n\n  if (a instanceof Date && b instanceof Date) {\n    return a.getTime() === b.getTime();\n  }\n\n  if (a instanceof RegExp && b instanceof RegExp) {\n    return a.source === b.source && a.flags === b.flags;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) {\n      return false;\n    }\n    for (let i = 0; i < a.length; i++) {\n      if (!deepEqual(a[i], b[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  if (Array.isArray(a) !== Array.isArray(b)) {\n    return false;\n  }\n\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const keysA = Object.keys(a);\n    const keysB = Object.keys(b);\n\n    if (keysA.length !== keysB.length) {\n      return false;\n    }\n\n    for (const key of keysA) {\n      if (!Object.prototype.hasOwnProperty.call(b, key)) {\n        return false;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  return false;\n}\n","/**\n * Utility type that recursively maps the object type to the type of the resolved path.\n *\n * @example\n * type A = { user: { profile: { name: string } } };\n * type Result = ResolvePath<A, 'user.profile.name'>; // Result is string\n */\nexport type ResolvePath<T, P extends string> = P extends `${infer Head}.${infer Tail}`\n  ? Head extends keyof T\n    ? ResolvePath<T[Head], Tail>\n    : never\n  : P extends keyof T\n    ? T[P]\n    : never;\n\n/**\n * Resolves a nested path in an object, returning the value at the specified path.\n *\n * This function splits the provided `path` into keys and iterates through the object to access the\n * corresponding value at each key. If any part of the path is undefined or if the path leads to a non-object,\n * it returns `undefined`.\n *\n * @template T - The type of the object.\n * @template P - The dot-separated string path type.\n * @param obj - The object to resolve the path within.\n * @param path - The dot-separated string representing the path to the value.\n * @returns The value at the resolved path, or `undefined` if any part of the path is invalid.\n *\n * @example\n * const obj = { user: { profile: { name: 'John Doe' } } };\n * const result = resolvePath(obj, 'user.profile.name');\n * console.log(result); // 'John Doe'\n *\n * @example\n * const result2 = resolvePath(obj, 'user.address.city');\n * console.log(result2); // undefined\n */\nexport function resolvePath<T extends object, P extends string>(\n  obj: T,\n  path: P,\n): ResolvePath<T, P> | undefined {\n  const keys = path.split('.') as (keyof T)[];\n  let current: unknown = obj;\n\n  for (const key of keys) {\n    if (current && typeof current === 'object' && key in current) {\n      current = (current as Record<string | number | symbol, unknown>)[key];\n    } else {\n      return undefined;\n    }\n  }\n\n  return current as ResolvePath<T, P>;\n}\n","/**\n * Splits an array into chunks of the specified size.\n *\n * @template T - The type of array elements.\n * @param array - The array to split.\n * @param size - The size of each chunk (must be positive).\n * @returns An array of chunks.\n *\n * @example\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * chunk([1, 2, 3, 4], 2); // [[1, 2], [3, 4]]\n * chunk([1, 2, 3], 5); // [[1, 2, 3]]\n * chunk([], 2); // []\n */\nexport function chunk<T>(array: T[], size: number): T[][] {\n  if (size <= 0) {\n    throw new Error('Chunk size must be a positive number');\n  }\n\n  const result: T[][] = [];\n  for (let i = 0; i < array.length; i += size) {\n    result.push(array.slice(i, i + size));\n  }\n  return result;\n}\n","/**\n * Splits an array into two groups based on a predicate function.\n * The first array contains elements that satisfy the predicate,\n * the second contains elements that don't.\n *\n * @template T - The type of array elements.\n * @param array - The array to partition.\n * @param predicate - The function to test each element.\n * @returns A tuple of [truthy, falsy] arrays.\n *\n * @example\n * const numbers = [1, 2, 3, 4, 5, 6];\n * partition(numbers, n => n % 2 === 0); // [[2, 4, 6], [1, 3, 5]]\n *\n * @example\n * const users = [\n *   { name: 'Alice', active: true },\n *   { name: 'Bob', active: false },\n *   { name: 'Charlie', active: true }\n * ];\n * partition(users, u => u.active);\n * // [[{ name: 'Alice', active: true }, { name: 'Charlie', active: true }], [{ name: 'Bob', active: false }]]\n */\nexport function partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]] {\n  const truthy: T[] = [];\n  const falsy: T[] = [];\n\n  for (const item of array) {\n    if (predicate(item)) {\n      truthy.push(item);\n    } else {\n      falsy.push(item);\n    }\n  }\n\n  return [truthy, falsy];\n}\n","/**\n * Groups an array of items based on a provided predicate function.\n *\n * @template K - The type of keys produced by the predicate, typically a string, number, or symbol.\n * @template V - The type of items in the collection.\n * @param collection - The array of items to be grouped.\n * @param predicate - A function that takes an item and returns a key by which to group the item.\n * @returns An object where each key is a group identifier produced by the predicate,\n * and the value is an array of items belonging to that group.\n *\n * @example\n * // Group an array of people by their age\n * const people = [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 25 }, { name: 'Charlie', age: 30 }];\n * const groupedByAge = groupBy(people, person => person.age);\n * // Output:\n * // {\n * //   25: [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 25 }],\n * //   30: [{ name: 'Charlie', age: 30 }]\n * // }\n */\nexport function groupBy<K extends string | number | symbol, V>(\n  collection: V[],\n  predicate: (item: V) => K,\n): Record<K, V[]> {\n  return collection.reduce(\n    (groups, item) => {\n      const groupKey = predicate(item);\n      if (!groups[groupKey]) {\n        groups[groupKey] = [];\n      }\n      groups[groupKey].push(item);\n      return groups;\n    },\n    {} as Record<K, V[]>,\n  );\n}\n","/**\n * ngx-com/utils\n * Utility function exports for ngx-com library\n */\n\nexport { mergeClasses } from './merge-classes';\n\n// Function utilities\nexport { debounce, type DebouncedFn, type DebounceOptions } from './debounce';\nexport { throttle, type ThrottledFn } from './throttle';\nexport { retry, type RetryOptions } from './retry';\n\n// Object utilities\nexport { pick } from './pick';\nexport { omit } from './omit';\nexport { deepClone } from './deep-clone';\nexport { deepMerge } from './deep-merge';\nexport { deepEqual } from './deep-equal';\nexport { isPlainObject } from './is-plain-object';\nexport { resolvePath, type ResolvePath } from './resolve-path';\n\n// Array utilities\nexport { chunk } from './chunk';\nexport { partition } from './partition';\nexport { groupBy } from './group-by';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}