@toolpad/utils/modern/collections.d.ts

Shared utilities used by Toolpad packages.

export declare function asArray<T>(maybeArray: T | T[]): T[];
type PropertiesOf<P> = Extract<keyof P, string>;
type Require<T, K extends keyof T> = T & { [P in K]-?: T[P] };
type Ensure<U, K extends PropertyKey> = K extends keyof U ? Require<U, K> : U & Record<K, unknown>;
/**
 * Type aware version of Object.protoype.hasOwnProperty.
 * See https://fettblog.eu/typescript-hasownproperty/
 */
export declare function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is Ensure<X, Y>;
/**
 * Maps `obj` to a new object. The `mapper` function receives an entry array of key and value and
 * is allowed to manipulate both. It can also return `null` to omit a property from the result.
 */
export declare function mapProperties<P, L extends PropertyKey, U>(obj: P, mapper: <K extends PropertiesOf<P>>(old: [K, P[K]]) => [L, U] | null): Record<L, U>;
/**
 * Maps an objects' property keys. The result is a new object with the mapped keys, but the same values.
 */
export declare function mapKeys<U>(obj: Record<string, U>, mapper: (old: string) => string): Record<string, U>;
/**
 * Maps an objects' property values. The result is a new object with the same keys, but mapped values.
 */
export declare function mapValues<P, V>(obj: P, mapper: (old: P[PropertiesOf<P>], key: PropertiesOf<P>) => V): Record<PropertiesOf<P>, V>;
/**
 * Filters an objects' property values. Similar to `array.filter` but for objects. The result is a new
 * object with all the properties removed for which `filter` returned `false`.
 */
export declare function filterValues<K extends PropertyKey, P, Q extends P>(obj: Record<K, P>, filter: (old: P) => old is Q): Record<K, Q>;
export declare function filterValues<P>(obj: P, filter: (old: P[keyof P]) => boolean): Partial<P>;
export declare function filterValues<U>(obj: Record<string, U>, filter: (old: U) => boolean): Record<string, U>;
/**
 * Filters an objects' property keys. Similar to `array.filter` but for objects. The result is a new
 * object with all the properties removed for which `filter` returned `false`.
 */
export declare function filterKeys<P>(obj: P, filter: (old: keyof P) => boolean): Partial<P>;
export declare function filterKeys<U>(obj: Record<string, U>, filter: (old: string) => boolean): Record<string, U>;
/**
 * Compares the properties of two objects. Returns `true` if all properties are strictly equal, `false`
 * otherwise.
 * Pass a subset of properties to only compare those.
 */
export declare function equalProperties<P extends object>(obj1: P, obj2: P, subset?: (keyof P)[]): boolean;
export {};