ts-prime/dist/es/guards.d.ts

A utility library for JavaScript and Typescript.

declare type DefinitelyString<T> = Extract<T, string> extends never ? string : Extract<T, string> extends any ? string : Extract<T, string>;
/**
 * Checks if `data` is `Number`
 * @param data - Anything
 * @example
 * const item = { data: 1 } as { data: number } | string
 * if (P.isString(item)) {
 *    console.log("My name is", item)
 * }
 * @category Guard
 */
export declare function isString<T>(data: T): data is DefinitelyString<T>;
declare type DefinitelyNumber<T> = Extract<T, number> extends never ? number : Extract<T, number> extends any ? number : Extract<T, number>;
/**
 * Checks if `data` is `Number`
 * @param data - Anything
 * @example
 * const item = { data: 1 } as { data: number } | number
 * if (P.isNumber(item)) {
 *    console.log("My phone number is", item)
 * }
 * @category Guard
 */
export declare function isNumber<T>(data: T): data is DefinitelyNumber<T>;
/**
 * Checks if `data` is defined
 * @param data - Anything
 * @example
 * const item = { data: 1 } as { data: number } | undefined
 * if (P.isDefined(item)) {
 *    console.log(item.data)
 * }
 * @category Guard
 */
export declare function isDefined<T>(data: T): data is NonNullable<T>;
declare type DefinitelyBoolean<T> = Extract<T, boolean> extends never ? boolean : Extract<T, boolean> extends any ? boolean : Extract<T, number>;
/**
 * Checks if `data` is boolean
 * @param data - Anything
 * @example
 * const item = false as { data: number } | undefined | boolean
 * if (P.isBoolean(item)) {
 *    console.log(item.data)
 * }
 * @category Guard
 */
export declare function isBoolean<T>(data: T): data is DefinitelyBoolean<T>;
declare type DefinitelyPromise<T extends unknown> = Extract<T, Promise<any>> extends never ? Promise<unknown> : Extract<T, Promise<any>>;
/**
 * Checks if `data` is `Promise`.
 * @param data - Anything
 * @example
 * const item = { data: 1 } as { data: number } | Promise<string[]>
 * if (P.isPromise(item)) {
 *    const result = await item
 *    console.log(Promise resolved,result.map((q)=> q.match(/.../)))
 * }
 * // Item is not promise
 * @category Guard
 */
export declare function isPromise<T>(data: T): data is DefinitelyPromise<T>;
declare type DefinitelyArray<T extends unknown> = Extract<T, Array<any> | ReadonlyArray<any>> extends never ? ReadonlyArray<unknown> : Extract<T, Array<any> | ReadonlyArray<any>>;
/**
 * Checks if `data` is `array`.
 * @param data - Anything
 * @example
 * const item = { data: 1 } as { data: number } | string[]
 * if (P.isArray(item)) {
 *    console.log(item.map((q)=> q.match(/.../)))
 * }
 *
 * const items = [{ data: 1 },[],"1",4,P.clamp].filter(P.isArray) //=> ["1"]
 * @category Guard
 */
export declare function isArray<T extends unknown>(data: T): data is DefinitelyArray<T>;
declare type DefinitelyObject<T extends unknown> = Exclude<Extract<T, object>, Array<any> | Function | ReadonlyArray<any>> extends never ? {
    [k: string]: unknown;
} : Exclude<Extract<T, object>, Array<any> | Function | ReadonlyArray<any>>;
/**
 * Checks if `data` is `object`.
 * @warning This function does not treat `Array` as `object`
 * @param data - Anything
 * @example
 * const item = { data: 1 } as { data: number } | string[]
 * if (P.isObject(item)) {
 *    console.log(item.data)
 * }
 *
 * const items = [{ data: 1 },[],1,4,P.clamp].filter(P.isObject) //=> [{ data: 1 }]
 * @category Guard
 */
export declare function isObject<T extends unknown>(data: T): data is DefinitelyObject<T>;
declare type DefinitelyFunction<T> = Extract<T, Function> extends never ? Function : Extract<T, Function>;
/**
 * Checks if `data` is `function`
 * @param data - Anything
 * @example
 * const item = P.clamp as unknown
 * if (P.isNil(item)) {
 *    // Item is definitely function
 *    console.log('Nice function', item.name)
 * }
 *
 * const items = [1,2,3,4,P.clamp].filter(P.isFunction) //=> [P.clamp]
 * @category Guard
 */
export declare function isFunction<T>(data: T): data is DefinitelyFunction<T>;
/**
 * Checks if `data` is `null` or `undefined`. Executes basic `data == null` evaluation
 * @param data - Anything
 * @example
 * const item = undefined as unknown
 * if (P.isNil(item)) {
 *    // Item is definitely null | undefined
 *    console.log('Do something')
 * }
 *
 * const items = [1,2,3,4,undefined].filter(P.isNil) //=> [undefined]
 * @category Guard
 */
export declare function isNil<T>(data: T): data is Extract<T, null | undefined>;
declare type DefinitelyError<T> = Extract<T, Error> extends never ? Error : Extract<T, Error>;
/**
 * Checks if `data` is instance of Error class
 * @param data - Anything
 * @example
 * const item = new Error('Error') as unknown
 * if (P.isError(item)) {
 *    // This is definitely an error and Typescript resolves it
 *    console.log(item.message)
 * }
 *
 * const items = [1,2,3,4,new Error('Error')].filter(P.isError) //=> [new Error('Error')]
 * @category Guard
 */
export declare function isError<T>(data: T): data is DefinitelyError<T>;
/**
 * Inverse predicate
 * @param predicate - predicate function
 * @example
 * const data = [new Error('sample'), 1, 2].filter(P.isNot(P.isError)) // [1,2]
 * @category Guard
 */
export declare function isNot<T, S>(predicate: (data: T) => data is S): (data: T) => data is Exclude<T, S>;
export declare function isNot<T>(predicate: (data: T) => any): (data: T) => boolean;
/**
 * Checks if object contains defined
 * @param predicate - predicate function
 * @example
 * const data = [new Error('sample'), 1, 2].filter(P.isNot(P.isError)) // [1,2]
 * @category Guard
 */
export declare function haveKeys<K extends string>(keys: ReadonlyArray<K>): <T extends {
    [k: string]: unknown;
}>(data: T) => data is T & {
    [k in K]: NonNullable<T[k]>;
};
export {};
//# sourceMappingURL=guards.d.ts.map