@stnekroman/tstools/dist/Types.d.ts

Set of handy tools for TypeScript development

export declare namespace Types {
    type Primitive = undefined | null | boolean | string | number | bigint | symbol;
    type Mutable<T> = {
        -readonly [P in keyof T]: T[P];
    };
    type WithRequired<T, PROPS extends keyof T> = T & Required<Pick<T, PROPS>>;
    type WithOptional<T, PROPS extends keyof T> = Omit<T, PROPS> & Partial<Pick<T, PROPS>>;
    type NonFunction<T> = T extends Function ? never : T;
    type IF<T, BASE, RT = T, RF = never> = T extends BASE ? RT : RF;
    interface Newable<R = {}, ARGS extends any[] = any[]> {
        new (...args: ARGS): R;
    }
    type SerializableObject<T = unknown> = {
        [K in keyof T]: Required<T>[K] extends Function ? never : T[K] & SerializableObject<T[K]>;
    };
    type Serializable<T = unknown> = SerializableObject<NonFunction<T>>;
    type LastTypeFromTuple<T extends any[]> = T extends [...infer _, infer L] ? L : never;
    type ArrayToUnion<T> = T extends readonly unknown[] ? T[number] : T;
    type DeepPartial<T> = {
        [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
    };
    type DeepReadonly<T> = T extends Primitive | Function ? T : T extends [] ? DeepReadonlyArray<T> : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;
    type DeepReadonlyArray<T> = ReadonlyArray<DeepReadonly<T>>;
    type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
    type DeepReadonlySet<T> = ReadonlySet<DeepReadonly<T>>;
    type DeepReadonlyObject<T> = {
        readonly [K in keyof T]: DeepReadonly<T[K]>;
    };
    type ReadonlyDate = Omit<Date, `set${string}`>;
    type KeysWithValsOfType<T, V> = keyof {
        [P in keyof T as T[P] extends V ? P : never]: P;
    };
    type KeyForValue<E extends Record<PropertyKey, unknown>, V extends E[keyof E]> = {
        [K in keyof E]: E[K] extends V ? (V extends E[K] ? K : never) : never;
    }[keyof E];
    type FunctionPropertyNames<T> = Types.KeysWithValsOfType<T, (...args: unknown[]) => unknown>;
    type addSuffixesToType<TEMPLATE_TYPE, SUFFIXES extends string | number> = {
        [KEY in keyof TEMPLATE_TYPE as `${KEY & string}${SUFFIXES}`]?: TEMPLATE_TYPE[KEY];
    };
    type addPrefixesToType<TEMPLATE_TYPE, PREFIXES extends string | number> = {
        [KEY in keyof TEMPLATE_TYPE as `${PREFIXES}${KEY & string}`]?: TEMPLATE_TYPE[KEY];
    };
}