@clerc/utils/dist/index.d.mts

Clerc utils

//#region src/types/type-fest.d.ts
type LiteralUnion<LiteralType, BaseType> = LiteralType | (BaseType & Record<never, never>);
type Prettify<T> = { [K in keyof T]: T[K] } & {};
type Primitive = null | undefined | string | number | boolean | symbol | bigint;
type BuiltIns = Primitive | void | Date | RegExp;
type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
type UnknownArray = readonly unknown[];
type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;
type ConditionalDeepPrettify<T, E = never, I = unknown> = T extends E ? T : T extends I ? { [TypeKey in keyof T]: ConditionalDeepPrettify<T[TypeKey], E, I> } : T;
type DeepPrettify<T, E = never> = ConditionalDeepPrettify<T, E | NonRecursiveType | MapsSetsOrArrays, object>;
type IsAny<T> = 0 extends 1 & T ? true : false;
type RequireExactlyOne<T, Keys extends keyof T = keyof T> = { [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, never>> }[Keys] & Omit<T, Keys>;
type RequireExactlyOneOrNone<T, Keys extends keyof T = keyof T> = ({ [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, never>> }[Keys] & Omit<T, Keys>) | (Partial<Record<Keys, never>> & Omit<T, Keys>);
//#endregion
//#region src/types/index.d.ts
type ToArray<T> = T extends any[] ? T : [T];
type MaybeArray<T> = T | T[];
type MaybeGetter<T> = T | (() => T);
type MaybeAsyncGetter<T> = T | (() => T | Promise<T>);
type PartialRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
type CamelCase<S extends string> = S extends `${infer Head} ${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : S extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : S;
//#endregion
//#region src/index.d.ts
declare const looseIsArray: <T>(arr: any) => arr is readonly T[];
declare const toArray: <T>(a: MaybeArray<T>) => T[];
/**
* Converts a dash- or space-separated string to camelCase.
*
* Not using regexp for better performance, because this function is used in
* parser.
*/
declare function camelCase(str: string): string;
declare function joinWithAnd(values: string[]): string;
declare const kebabCase: <T extends string>(s: T) => string;
declare const formatFlagName: (n: string) => string;
declare const formatVersion: (v: string) => string;
declare const isTruthy: <T>(item: T) => item is Exclude<T, false | null | undefined>;
declare const objectIsEmpty: (obj: Record<string, any>) => boolean;
declare const resolveValue: <T>(value: MaybeGetter<T>) => T;
declare const resolveAsyncValue: <T>(value: MaybeAsyncGetter<T>) => Promise<T>;
declare const hasOwn: (obj: object, key: PropertyKey) => boolean;
//#endregion
export { CamelCase, DeepPrettify, IsAny, LiteralUnion, MaybeArray, MaybeAsyncGetter, MaybeGetter, PartialRequired, Prettify, RequireExactlyOne, RequireExactlyOneOrNone, ToArray, UnionToIntersection, camelCase, formatFlagName, formatVersion, hasOwn, isTruthy, joinWithAnd, kebabCase, looseIsArray, objectIsEmpty, resolveAsyncValue, resolveValue, toArray };