react-classnaming/dist/ts-swiss.types.d.ts

Tools to establish CSS classes as an explicit abstraction layer and to handle it as an interface between React and CSSStyleDeclaration

export declare type Ever<T, V, D = EmptyObject> = [T] extends [never] ? D : V;
export declare type Ever0<T, D = never> = [T] extends [never] ? D : T;
export declare type EmptyObject = Record<never, never>;
export declare type AnyObject = Record<string, any>;
export declare type Falsy = undefined | null | false | 0 | "";
/** @see https://stackoverflow.com/a/49579497/9412937 */
export declare type RequiredKeys<T> = {
    [K in keyof T]-?: ({} extends {
        [P in K]: T[K];
    } ? never : K);
}[keyof T];
export declare type BoolDict = Record<string, boolean>;
/** @see https://github.com/microsoft/TypeScript/issues/31153#issuecomment-487872268 */
export declare type KnownKeys<T> = {
    [K in keyof T]: string extends K ? never : number extends K ? never : K;
} extends {
    [_ in keyof T]: infer U;
} ? U : never;
export declare type OmitIndexed<T> = Pick<T, KnownKeys<T> & keyof T>;
export declare type Primitive = undefined | null | boolean | number | string | symbol | bigint;
export declare type Strip<Str extends string, Delimiter extends string, toNever extends boolean = false> = Str extends `${infer Lead}${Delimiter}${string}` ? Lead : toNever extends false ? Str : never;
export declare type Cut<Str extends string, Delimiter extends string, toNever extends boolean = false> = Str extends `${string}${Delimiter}${infer Back}` ? Back : toNever extends false ? Str : never;
export declare type NoSubString<Str extends string, Sub extends string> = Exclude<Str, `${string}${Sub}${string}`>;
export declare type Subest<Base, Extendent> = string extends keyof Base ? Extendent : Base extends Extendent ? Extendent : Base;
export declare type Extends<T, V, X> = [T extends V ? true : never] extends [never] ? never : X;
export declare type PartDeep<T> = Exclude<T, AnyObject> | Extract<T, any[]> | (T extends any[] ? never : T extends AnyObject ? Ever<keyof Extract<Exclude<T, any[]>, AnyObject>, {
    [K in keyof Extract<Exclude<T, any[]>, AnyObject>]?: PartDeep<Extract<Exclude<T, any[]>, AnyObject>[K]>;
}, never> : never);
export declare type KeyOf<T> = [T] extends [never] ? never : T extends AnyObject ? Extract<keyof T, string> : never;
/** @see https://stackoverflow.com/a/50375286/10325032 */
export declare type UnionToIntersection<Union> = (Union extends any ? (argument: Union) => void : never) extends (argument: infer Intersection) => void ? Intersection : never;