@voxpelli/typed-utils/lib/array.d.ts

My personal (type-enabled) utils / helpers

/** @import { NonGenericString } from './types/string-types.d.ts' */
/**
 * @template {unknown[]|(readonly unknown[])} T
 * @template {undefined|null|false|string} [V=undefined]
 * @template {NonGenericString<V>} [R=NonGenericString<V>]
 * @param {T} input
 * @param {NonGenericString<V, 'Only accepting literal strings and undefined|null|false'>} [value]
 * @returns {Exclude<T[number], R>[]}
 */
export function filter<T extends unknown[] | (readonly unknown[]), V extends undefined | null | false | string = undefined, R extends NonGenericString<V> = NonGenericString<V>>(input: T, value?: NonGenericString<V, "Only accepting literal strings and undefined|null|false">): Exclude<T[number], R>[];
/**
 * @template {unknown[]|(readonly unknown[])} T
 * @template R
 * @param {T} input
 * @param {(value: T[number]) => value is R} callback
 * @returns {R[]}
 */
export function filterWithCallback<T extends unknown[] | (readonly unknown[]), R>(input: T, callback: (value: T[number]) => value is R): R[];
/**
 * @template {(value: unknown) => value is any} CB
 * @param {unknown} value
 * @param {CB} callback
 * @returns {value is Array<CB extends ((value: unknown) => value is infer U) ? U : never>}
 */
export function isArrayOfType<CB extends (value: unknown) => value is any>(value: unknown, callback: CB): value is Array<CB extends ((value: unknown) => value is infer U) ? U : never>;
/**
 * Array.isArray() on its own give type any[]
 *
 * @deprecated Use typesafeIsArray() instead
 * @param {unknown} value
 * @returns {value is unknown[]}
 */
export function isUnknownArray(value: unknown): value is unknown[];
/**
 * Array.isArray() on its own give type any[]
 *
 * @param {unknown} value
 * @returns {value is unknown[]}
 */
export function typesafeIsArray(value: unknown): value is unknown[];
/**
 * @param {unknown} value
 * @returns {value is string[]}
 */
export function isStringArray(value: unknown): value is string[];
/**
 * @template {Set<unknown> | Array<unknown> | ReadonlyArray<unknown>} C
 * @param {C} collection
 * @param {unknown} searchElement
 * @returns {searchElement is (C extends Iterable<infer U> ? U : never)}
 */
export function guardedArrayIncludes<C extends Set<unknown> | Array<unknown> | ReadonlyArray<unknown>>(collection: C, searchElement: unknown): searchElement is (C extends Iterable<infer U> ? U : never);
/**
 * Convert a value to an array if it isn't already one.
 *
 * If `value` is already an array, returns it as-is. Otherwise, wraps `value`
 * in a new single-element array. Useful for normalizing inputs that may be
 * either a single item or an array of items.
 *
 * @template T
 * @param {T|T[]} value - Value to ensure is an array
 * @returns {T[]} The value as an array
 * @see {@link typesafeIsArray} - Used internally for type-safe array checking
 * @example
 * ```js
 * ensureArray('single'); // ['single']
 * ensureArray(['already', 'array']); // ['already', 'array']
 * ```
 */
export function ensureArray<T>(value: T | T[]): T[];
import type { NonGenericString } from './types/string-types.d.ts';
//# sourceMappingURL=array.d.ts.map