@catbee/utils 0.0.8-rc.3 → 1.0.1

package/build/esm/utils/obj.utils.js

@@ -1,412 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2025 Catbee Technologies. https://catbee-utils.npm.hprasath.com/license
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-/**
- * Checks whether the object has no own enumerable properties.
- *
- * @param {Record<any, any>} obj - The object to check.
- * @returns {boolean} True if the object is empty, false otherwise.
- */
-export function isObjEmpty(obj) {
-    return !!obj && typeof obj === 'object' && Object.keys(obj).length === 0;
-}
-/**
- * Returns a new object with only the specified keys picked.
- *
- * @template T
- * @template K
- * @param {T} obj - The source object.
- * @param {K[]} keys - Keys to pick from the object.
- * @returns {Pick<T, K>} New object with picked keys.
- */
-export function pick(obj, keys) {
-    return Object.fromEntries(keys.map(key => [key, obj[key]]));
-}
-/**
- * Returns a new object with the specified keys omitted.
- *
- * @template T
- * @template K
- * @param {T} obj - The source object.
- * @param {K[]} keys - Keys to omit from the object.
- * @returns {Omit<T, K>} New object without omitted keys.
- */
-export function omit(obj, keys) {
-    return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
-}
-/**
- * Deeply merges multiple objects into the target object (mutates and returns the target object, not pure).
- *
- * @template T
- * @param {T} target - The object to merge into (will be mutated).
- * @param {...any[]} sources - The objects to merge from.
- * @returns {T} The merged object (same as target).
- */
-export function deepObjMerge(target, ...sources) {
-    if (!sources.length)
-        return target;
-    const seen = new WeakMap();
-    seen.set(target, target);
-    for (const s of sources) {
-        if (s && typeof s === 'object') {
-            seen.set(s, target);
-        }
-    }
-    function deepClone(value) {
-        if (value === null || typeof value !== 'object')
-            return value;
-        if (seen.has(value))
-            return seen.get(value);
-        // Date
-        if (value instanceof Date) {
-            return new Date(value.getTime());
-        }
-        // Array
-        if (Array.isArray(value)) {
-            const clone = [];
-            seen.set(value, clone);
-            value.forEach((item, i) => (clone[i] = deepClone(item)));
-            return clone;
-        }
-        // Set
-        if (value instanceof Set) {
-            const clone = new Set();
-            seen.set(value, clone);
-            value.forEach(item => clone.add(deepClone(item)));
-            return clone;
-        }
-        // Map
-        if (value instanceof Map) {
-            const clone = new Map();
-            seen.set(value, clone);
-            value.forEach((val, key) => clone.set(key, deepClone(val)));
-            return clone;
-        }
-        // RegExp
-        if (value instanceof RegExp) {
-            return new RegExp(value.source, value.flags);
-        }
-        // ArrayBuffer
-        if (value instanceof ArrayBuffer) {
-            return value.slice(0);
-        }
-        // TypedArrays
-        if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
-            const typed = value; // cast for TS
-            const ctor = typed.constructor;
-            // List of standard TypedArray constructors
-            const typedArrayCtors = [
-                Int8Array,
-                Uint8Array,
-                Uint8ClampedArray,
-                Int16Array,
-                Uint16Array,
-                Int32Array,
-                Uint32Array,
-                Float32Array,
-                Float64Array,
-                BigInt64Array,
-                BigUint64Array
-            ].filter(Boolean); // filter out undefined (for environments without BigInt)
-            const typedArrayCtorSet = new Set(typedArrayCtors);
-            if (typeof ctor === 'function' && typedArrayCtorSet.has(ctor)) {
-                // Defensive: ensure buffer is an ArrayBuffer and slice is available
-                const buffer = typed.buffer && typeof typed.buffer.slice === 'function' ? typed.buffer.slice(0) : typed.buffer;
-                const clone = new ctor(buffer, typed.byteOffset, typed.length);
-                seen.set(value, clone);
-                return clone;
-            }
-            else if (typeof typed.slice === 'function') {
-                // Fallback: try using slice if available (e.g., Node.js Buffer)
-                const clone = typed.slice();
-                seen.set(value, clone);
-                return clone;
-            }
-            else {
-                // Could not safely clone, throw an error for better debugging
-                throw new Error('Cannot deep clone unknown TypedArray type: ' + (typed && typed.constructor && typed.constructor.name));
-            }
-        }
-        const clone = Object.create(Object.getPrototypeOf(value));
-        seen.set(value, clone);
-        Reflect.ownKeys(value).forEach(key => {
-            const descriptor = Object.getOwnPropertyDescriptor(value, key);
-            if (descriptor.get || descriptor.set) {
-                Object.defineProperty(clone, key, descriptor);
-            }
-            else {
-                clone[key] = deepClone(value[key]);
-            }
-        });
-        return clone;
-    }
-    function mergeProp(target, source, key) {
-        const targetValue = target[key];
-        const sourceValue = source[key];
-        // Ignore undefined in source
-        if (sourceValue === undefined)
-            return;
-        // Primitives → overwrite directly
-        if (sourceValue === null || typeof sourceValue !== 'object') {
-            target[key] = sourceValue;
-            return;
-        }
-        // Arrays → replace (lodash behavior)
-        if (Array.isArray(sourceValue)) {
-            target[key] = deepClone(sourceValue);
-            return;
-        }
-        // Special cloneable objects
-        if (sourceValue instanceof Date ||
-            sourceValue instanceof RegExp ||
-            sourceValue instanceof Set ||
-            sourceValue instanceof Map ||
-            sourceValue instanceof ArrayBuffer ||
-            (ArrayBuffer.isView(sourceValue) && !(sourceValue instanceof DataView))) {
-            target[key] = deepClone(sourceValue);
-            return;
-        }
-        // Plain objects → recursive merge
-        if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
-            for (const k of Reflect.ownKeys(sourceValue)) {
-                mergeProp(targetValue, sourceValue, k);
-            }
-            return;
-        }
-        // Default → overwrite with clone
-        target[key] = deepClone(sourceValue);
-    }
-    for (const source of sources) {
-        if (source == null)
-            continue;
-        for (const key of Reflect.ownKeys(source)) {
-            mergeProp(target, source, key);
-        }
-    }
-    return target;
-}
-/**
- * Checks if a value is a plain object (i.e., not an array, null, or a built-in object).
- *
- * @param value - The value to check.
- * @returns True if the value is a plain object, false otherwise.
- */
-export function isPlainObject(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    if (Array.isArray(value))
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}
-/**
- * Flattens a nested object using dot notation for keys (e.g., `{a: {b: 1}}` → `{ "a.b": 1 }`).
- *
- * @template T
- * @param {T} obj - The object to flatten.
- * @param {string} [prefix=""] - Optional prefix for nested keys (used internally).
- * @returns {Record<string, any>} A new object with flattened keys.
- */
-export function flattenObject(obj, prefix = '') {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-        const newKey = prefix ? `${prefix}.${key}` : key;
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            Object.assign(acc, flattenObject(value, newKey));
-        }
-        else {
-            acc[newKey] = value;
-        }
-        return acc;
-    }, {});
-}
-/**
- * Safely gets the value of a deeply nested key in an object using dot/bracket notation path.
- *
- * @template T
- * @param {T} obj - The object to extract from.
- * @param {string} path - String path using dot and/or bracket notation (e.g., 'user.friends[0].name').
- * @returns {any} The value at the given path, or undefined if not found.
- */
-export function getValueByPath(obj, path) {
-    if (!obj || typeof obj !== 'object')
-        return undefined;
-    // Convert path like "a.b[0].c" into ["a", "b", "0", "c"]
-    const parts = path
-        .replace(/\[(\d+)\]/g, '.$1') // convert [0] to .0
-        .split('.')
-        .filter(Boolean); // remove empty strings
-    return parts.reduce((acc, key) => acc?.[key], obj);
-}
-/**
- * Sets a value at a deeply nested key in an object using dot/bracket notation path.
- * Creates intermediate objects and arrays as needed.
- *
- * @template T
- * @param {T} obj - The object to modify.
- * @param {string} path - String path using dot and/or bracket notation (e.g., 'user.friends[0].name').
- * @param {any} value - The value to set at the path.
- * @returns {T} The modified object.
- */
-export function setValueByPath(obj, path, value) {
-    if (!obj || typeof obj !== 'object')
-        return obj;
-    // Convert path like "a.b[0].c" into ["a", "b", "0", "c"]
-    const parts = path
-        .replace(/\[(\d+)\]/g, '.$1') // convert [0] to .0
-        .split('.')
-        .filter(Boolean); // remove empty strings
-    // Handle empty path
-    if (parts.length === 0)
-        return obj;
-    let current = obj;
-    // Navigate to the parent of the target property
-    for (let i = 0; i < parts.length - 1; i++) {
-        const key = parts[i];
-        const isArrayIndex = !isNaN(Number(parts[i + 1]));
-        if (current[key] === undefined) {
-            // Create intermediate object or array based on next key type
-            current[key] = isArrayIndex ? [] : {};
-        }
-        current = current[key];
-    }
-    // Set the value at the final key
-    const finalKey = parts[parts.length - 1];
-    current[finalKey] = value;
-    return obj;
-}
-/**
- * Performs a deep equality check between two objects.
- *
- * @param {any} a - First value to compare.
- * @param {any} b - Second value to compare.
- * @returns {boolean} True if values are deeply equal.
- */
-export function isEqual(a, b) {
-    // Check if primitives or references to the same object
-    if (a === b)
-        return true;
-    // Check if either is null/undefined or not an object
-    if (a == null || b == null || typeof a !== 'object' || typeof b !== 'object') {
-        return false;
-    }
-    // Handle Date objects
-    if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
-    }
-    // If one is Date but the other isn't
-    if (a instanceof Date || b instanceof Date) {
-        return false;
-    }
-    // Handle arrays
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        // Check each element
-        for (let i = 0; i < a.length; i++) {
-            if (!isEqual(a[i], b[i]))
-                return false;
-        }
-        return true;
-    }
-    // If one is Array but the other isn't
-    if (Array.isArray(a) || Array.isArray(b)) {
-        return false;
-    }
-    // Compare object keys
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length)
-        return false;
-    // Check if every key in A exists in B and has the same value
-    return keysA.every(key => Object.prototype.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]));
-}
-/**
- * Filters object properties based on a predicate function.
- *
- * @template T
- * @param {T} obj - The source object.
- * @param {(value: any, key: string, obj: T) => boolean} predicate - Filter function.
- * @returns {Partial<T>} New object with filtered properties.
- */
-export function filterObject(obj, predicate) {
-    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => predicate(value, key, obj)));
-}
-/**
- * Maps object values to new values using a mapping function.
- *
- * @template T
- * @template U
- * @param {T} obj - The source object.
- * @param {(value: any, key: string, obj: T) => U} mapFn - Mapping function.
- * @returns {Record<keyof T, U>} New object with mapped values.
- */
-export function mapObject(obj, mapFn) {
-    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, mapFn(value, key, obj)]));
-}
-/**
- * Recursively freezes an object and all its properties.
- * Makes an object immutable.
- *
- * @template T
- * @param {T} obj - The object to freeze.
- * @returns {Readonly<T>} The frozen object.
- */
-export function deepFreeze(obj) {
-    // Freeze primitive properties
-    Object.freeze(obj);
-    // Recursively freeze nested objects
-    for (const prop of Object.getOwnPropertyNames(obj)) {
-        const value = obj[prop];
-        if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
-            deepFreeze(value);
-        }
-    }
-    return obj;
-}
-/**
- * Safely checks if a value is an object (not null, not array).
- *
- * @param {unknown} value - Value to check.
- * @returns {boolean} True if value is a non-null, non-array object.
- */
-export function isObject(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-/**
- * Gets all paths in an object using dot notation.
- *
- * @param {Record<string, any>} obj - Object to analyze.
- * @param {string} [parentPath=""] - Internal param for recursion.
- * @returns {string[]} Array of all paths in dot notation.
- */
-export function getAllPaths(obj, parentPath = '') {
-    if (!isObject(obj))
-        return [];
-    return Object.entries(obj).flatMap(([key, value]) => {
-        const currentPath = parentPath ? `${parentPath}.${key}` : key;
-        if (isObject(value)) {
-            return [currentPath, ...getAllPaths(value, currentPath)];
-        }
-        return [currentPath];
-    });
-}

package/build/esm/utils/performance.utils.d.ts

@@ -1,135 +0,0 @@
-/**
- * Options for timing function execution.
- */
-export interface TimingOptions {
-    /** Optional label for the timing (defaults to function name) */
-    label?: string;
-    /** Whether to log the timing (default: false) */
-    log?: boolean;
-    /** Log level to use if logging is enabled (default: 'debug') */
-    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
-}
-/**
- * Result of a timing operation.
- */
-export interface TimingResult {
-    /** Duration in milliseconds */
-    durationMs: number;
-    /** Duration in seconds */
-    durationSec: number;
-    /** Start timestamp */
-    startTime: number;
-    /** End timestamp */
-    endTime: number;
-    /** Label used for the timing */
-    label: string;
-}
-/**
- * Measure the execution time of a synchronous function.
- *
- * @param fn - Function to measure
- * @param options - Timing options
- * @returns Result containing the return value and timing information
- *
- * @example
- * ```typescript
- * const { result, timing } = timeSync(() => {
- *   // Some expensive operation
- *   return computeResult();
- * }, { label: 'Computation', log: true });
- *
- * console.log(`Result: ${result}, took ${timing.durationMs}ms`);
- * ```
- */
-export declare function timeSync<T>(fn: () => T, options?: TimingOptions): {
-    result: T;
-    timing: TimingResult;
-};
-/**
- * Measure the execution time of an asynchronous function.
- *
- * @param fn - Async function to measure
- * @param options - Timing options
- * @returns Promise resolving to result and timing information
- *
- * @example
- * ```typescript
- * const { result, timing } = await timeAsync(async () => {
- *   // Some expensive async operation
- *   const data = await fetchData();
- *   return processData(data);
- * }, { label: 'API Request', log: true });
- *
- * console.log(`Fetched ${result.length} items in ${timing.durationSec.toFixed(2)}s`);
- * ```
- */
-export declare function timeAsync<T>(fn: () => Promise<T>, options?: TimingOptions): Promise<{
-    result: T;
-    timing: TimingResult;
-}>;
-/**
- * Create a timing decorator for class methods.
- *
- * @param options - Timing options
- * @returns Method decorator
- *
- * @example
- * ```typescript
- * class DataService {
- *   @timed({ log: true, logLevel: 'info' })
- *   async fetchData() {
- *     // ...implementation
- *   }
- * }
- * ```
- */
-export declare function timed(options?: TimingOptions): (target: any, propertyKeyOrContext: string | symbol | any, descriptor?: PropertyDescriptor) => void;
-/**
- * Memoize function results with optional TTL and max cache size.
- *
- * @param fn - Function to memoize
- * @param options - Memoization options
- * @returns Memoized function
- *
- * @example
- * ```typescript
- * // Cache results for 30 seconds, with a maximum of 100 entries
- * const cachedFetch = memoize(
- *   async (url) => {
- *     const response = await fetch(url);
- *     return response.json();
- *   },
- *   { ttl: 30000, maxSize: 100, cacheKey: (url) => url }
- * );
- * ```
- */
-export declare function memoize<T, Args extends any[]>(fn: (...args: Args) => T, options?: {
-    /** Time-to-live in milliseconds (default: indefinite) */
-    ttl?: number;
-    /** Maximum cache size (default: unlimited) */
-    maxSize?: number;
-    /** Function to generate a cache key from arguments */
-    cacheKey?: (...args: Args) => string;
-    /** Auto-cleanup interval in milliseconds (default: disabled) */
-    autoCleanupMs?: number;
-}): (...args: Args) => T;
-/**
- * Track memory usage for a function execution.
- *
- * @param fn - Function to track
- * @param options - Memory tracking options
- * @returns Result and memory usage information
- */
-export declare function trackMemoryUsage<T>(fn: () => T, options?: {
-    /** Whether to log the memory usage (default: false) */
-    log?: boolean;
-    /** Label for the memory tracking (default: function name) */
-    label?: string;
-}): {
-    result: T;
-    memoryUsage: {
-        before: NodeJS.MemoryUsage;
-        after: NodeJS.MemoryUsage;
-        diff: Record<string, number>;
-    };
-};