@akala/core/dist/esm/each.d.ts

/**
 * Iterates over array-like structures using forEach
 * @template T - Element type
 * @param {T[] | ArrayLike<T>} array - Array or array-like object to iterate
 * @param {function(element: T, i: number): void} body - Callback executed for each element
 * @returns {void} - No return value
 */
export declare function array<T>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => void): void;
/**
 * Iterates over object properties
 * @template TIn - Object type
 * @param {TIn} o - Target object to iterate
 * @param {function(element: TIn[keyof TIn], i: keyof TIn): void} body - Callback executed for each property
 * @returns {void} - No return value
 */
export declare function object<TIn>(o: TIn, body: (element: TIn[keyof TIn], i: keyof TIn) => void): void;
/**
 * Universal iteration function for arrays/objects
 * @template T - Input type (array/object)
 * @param {T | T[]} it - Target collection to iterate
 * @param {function(element: any, i: any): void} body - Callback for each element/property
 * @overload
 * each(array: T[] | ArrayLike<T>, body: (element: T, i: number) => void): void
 * @overload
 * each(o: T, body: <U extends keyof T>(element: T[U], i: U) => void): void
 * @returns {void} - No return value
 */
export declare function each<T>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => void): void;
export declare function each<T>(o: T, body: <U extends keyof T>(element: T[U], i: U) => void): void;
/**
 * Filters array-like structures
 * @template T - Element type
 * @param {T[] | ArrayLike<T>} it - Input collection
 * @param {function(element: T, i: number): boolean} body - Filter predicate
 * @returns {T[]} - Array of matching elements
 */
export declare function grepArray<T>(it: T[] | ArrayLike<T>, body: (element: T, i: number) => boolean): T[];
/**
 * Type representing a projected object
 * @template T - Source type
 * @template U - Target type
 */
export type Proxy<T, U> = {
    [P in keyof T]: U;
};
/**
 * Filters object properties
 * @template T - Object type
 * @param {T} o - Target object
 * @param {function(element: T[keyof T], i: keyof T): boolean} body - Filter predicate
 * @param {boolean} asArray - Return results as array instead of object
 * @returns {(Partial<T> | T[keyof T][]) - Filtered results as object or array
 */
export declare function grepObject<T>(o: T, body: (element: T[keyof T], i: keyof T) => boolean, asArray?: true): T[keyof T][];
export declare function grepObject<T>(o: T, body: (element: T[keyof T], i: keyof T) => boolean, asArray: false): Partial<T>;
export declare function grepObject<T>(o: T, body: (element: T[keyof T], i: keyof T) => boolean, asArray: boolean): Partial<T> | T[keyof T][];
/**
 * Checks if value is array-like
 * @template T - Element type
 * @param {unknown} it - Value to check
 * @returns {it is ArrayLike<T>} - True if array-like
 */
export declare function isArrayLike<T>(t: T[]): true;
export declare function isArrayLike<T>(t: ArrayLike<T>): true;
export declare function isArrayLike<T>(t: unknown): t is ArrayLike<T>;
/**
 * Unified filter function for arrays/objects
 * @template T - Input type
 * @param {T | T[]} it - Target collection
 * @param {function(element: any, i: any): boolean} body - Filter predicate
 * @param {boolean} asArray - Return results as array
 * @returns {(T[] | Partial<T>)} - Filtered results
 */
export declare function grep<T>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => boolean): T[];
export declare function grep<T>(o: T, body: <U extends keyof T>(element: T[U], i: U) => boolean): Partial<T>;
export declare function grep<T, U extends keyof T>(o: T, body: (element: T[U], i: U) => boolean, asArray: true): T[U][];
/**
 * Transforms array elements
 * @template T - Input element type
 * @template U - Output element type
 * @param {T[] | ArrayLike<T>} it - Input collection
 * @param {function(element: T, i: number): U} body - Transformation function
 * @returns {U[]} - Transformed elements
 */
export declare function mapArray<T, U>(it: T[] | ArrayLike<T>, body: (element: T, i: number) => U): U[];
/**
 * Transforms object properties
 * @template TIn - Input object type
 * @template TResultValue - Output property type
 * @param {TIn} o - Target object
 * @param {function(element: TIn[keyof TIn], i: keyof TIn): TResultValue} body - Transformation function
 * @param {boolean} asArray - Return results as array
 * @returns {(TResultValue[] | {[P in keyof TIn]?: TResultValue})} - Transformed results
 */
export declare function mapObject<TIn, TResultValue>(o: TIn, body: (element: TIn[keyof TIn], i: keyof TIn) => TResultValue, asArray: true): TResultValue[];
export declare function mapObject<TIn, TResultValue>(o: TIn, body: (element: TIn[keyof TIn], i: keyof TIn) => TResultValue, asArray?: false): {
    [P in keyof TIn]?: TResultValue;
};
export declare function mapObject<TIn, TResultValue>(o: TIn, body: (element: TIn[keyof TIn], i: keyof TIn) => TResultValue, asArray?: boolean): any;
/**
 * Unified mapping function for arrays/objects
 * @template T - Input type
 * @template U - Output type
 * @param {T | T[]} it - Target collection
 * @param {function(element: any, i: any): any} body - Transformation function
 * @param {boolean} asArray - Return results as array
 * @returns {(U[] | Proxy<T, U>)} - Transformed results
 */
export declare function map<T, U>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => U): U[];
export declare function map<TIn, TKey extends keyof TIn, TResultValue>(o: TIn, body: (element: TIn[TKey], i: TKey) => TResultValue): Proxy<TIn, TResultValue>;
export declare function map<TIn, TKey extends keyof TIn, TResultValue>(o: TIn, body: (element: TIn[TKey], i: TKey) => TResultValue, asArray: true): TResultValue[];