Last active
May 21, 2026 09:08
-
-
Save albannurkollari/f7b0671647028a1b3047fe6a758161b5 to your computer and use it in GitHub Desktop.
Types
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /** biome-ignore-all lint/correctness/noUnusedVariables: <ambient> */ | |
| /** | |
| * Combines two strings with a given delimiter. | |
| */ | |
| type Combine<A, B, D extends Delimiter = '_'> = `${A}${D}${B}`; | |
| /** | |
| * A union type that allows given type while | |
| * also widening it with a base type. | |
| * | |
| * | |
| * Think of it as a way to suggest predefined literals | |
| * while still allowing any string (or other base type). | |
| */ | |
| type LiteralUnion<LiteralType, BaseType = string> = | |
| | LiteralType | |
| | (BaseType & Record<never, never>); | |
| /** | |
| * Joins an array of strings with a given delimiter. | |
| */ | |
| type JoinStrings< | |
| T extends string[], | |
| D extends Delimiter = ' ', | |
| Acc extends string = '', | |
| > = T extends [infer F extends string, ...infer R extends string[]] | |
| ? JoinStrings<R, D, Acc extends '' ? F : `${Acc}${D}${F}`> | |
| : Acc; | |
| /** | |
| * Converts a tuple of strings into a sentence-cased string, | |
| * joining with a delimiter. | |
| * */ | |
| type Sentence< | |
| T extends readonly [string, ...string[]], | |
| D extends Delimiter = ' ', | |
| > = JoinStrings< | |
| T extends [infer F extends string, ...infer R extends string[]] | |
| ? [F, ...{ [K in keyof R]: Lowercase<R[K] & string> }] | |
| : string[], | |
| D | |
| >; | |
| /** Converts a string to camelCase. */ | |
| type Camelize< | |
| S extends string, | |
| D extends Delimiter = '_', | |
| > = S extends `${infer Head}${D}${infer Tail}` | |
| ? `${Lowercase<Head>}${Capitalize<Camelize<Tail, D>>}` | |
| : Lowercase<S>; | |
| /** Converts a string to PascalCase. */ | |
| type Pascalize< | |
| S extends string, | |
| D extends Delimiter = '_', | |
| > = S extends `${infer Head}${D}${infer Tail}` | |
| ? `${Capitalize<Lowercase<Head>>}${Pascalize<Tail, D>}` | |
| : Capitalize<Lowercase<S>>; | |
| /** Applies camelCase conversion to a union of strings. */ | |
| type CamelCaseUnion<T extends string> = T extends T ? Camelize<T> : never; | |
| /** Converts the keys of an object to camelCase. */ | |
| type CamelCaseObj<T extends object> = { | |
| [K in keyof T as Camelize<K & string>]: T[K]; | |
| }; | |
| /** | |
| * Pads numbers less than 10 with a leading zero. | |
| */ | |
| type PadStartWithZero<T extends number | string> = `${T}` extends `${infer S}` | |
| ? S extends `${number}${number}` | |
| ? S | |
| : `0${S}` | |
| : never; |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /** biome-ignore-all lint/correctness/noUnusedVariables: <ambient> */ | |
| /** | |
| * Creates a numeric union type from 0 up to (but not including) Max. | |
| * */ | |
| type NumbersUpTo< | |
| Max extends number, | |
| R extends Array<number> = [], | |
| > = R['length'] extends Max ? R[number] : NumbersUpTo<Max, [...R, R['length']]>; | |
| /** | |
| * Creates a numeric union type from Min (inclusive) to Max (exclusive). | |
| */ | |
| type NumberRange<Min extends number, Max extends number> = Exclude< | |
| NumbersUpTo<Max>, | |
| NumbersUpTo<Min> | |
| >; | |
| /** Time formats and types */ | |
| type SECONDS = NumberRange<1, 60>; | |
| type MINUTES = NumberRange<1, 60>; | |
| type HOURS = NumberRange<1, 24>; | |
| type DAYS = NumberRange<1, 32>; | |
| type WEEKS = NumberRange<1, 55>; | |
| type MONTHS = NumberRange<1, 13>; |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /** biome-ignore-all lint/correctness/noUnusedVariables: <ambient> */ | |
| type UnknownRecord = Record<string, unknown>; | |
| /** Prettifies a type by flattening its structure. */ | |
| type Prettify<T> = { [Key in keyof T]: T[Key] } & unknown; | |
| type OmitKeys<T, K extends keyof NonNullable<T>> = Omit<T, K>; | |
| type PickKeys<T, K extends keyof NonNullable<T>> = Pick<T, K>; | |
| type PickRequired<T> = Pick<T, RequiredKeys<T>>; | |
| type RequiredKeys<T> = { | |
| [K in keyof T]-?: undefined extends T[K] ? never : K; | |
| }[keyof T]; | |
| type DisallowKeys<T, K extends keyof NonNullable<T>> = Prettify< | |
| Omit<T, K> & Neverize<T, K> | |
| >; | |
| type Neverize<T, K extends keyof T = keyof T> = { [P in K]?: never }; | |
| type Partialize<T, K extends keyof T = keyof T> = Omit<T, K> & | |
| Partial<Pick<T, K>>; | |
| type Requirify<T, K extends keyof T = keyof T> = { [P in K]-?: T[P] }; | |
| type OneOrTheOther< | |
| T, | |
| K1 extends keyof T, | |
| K2 extends Exclude<keyof T, K1>, | |
| > = Prettify< | |
| | (Partial<Pick<T, K1>> & Neverize<T, K2>) | |
| | (Partial<Pick<T, K2>> & Neverize<T, K1>) | |
| >; | |
| type RequireOneOrTheOther< | |
| T, | |
| K1 extends keyof T, | |
| K2 extends Exclude<keyof T, K1>, | |
| > = Prettify< | |
| (Requirify<T, K1> & Neverize<T, K2>) | (Requirify<T, K2> & Neverize<T, K1>) | |
| >; | |
| // type RequireOne<T, K extends keyof T> = K extends any | |
| type RequireOne<T, K extends keyof T> = K extends unknown | |
| ? Required<Pick<T, K>> & Partial<Omit<T, K>> | |
| : never; | |
| type KeyOrId<T extends string = string> = RequireOneOrTheOther< | |
| { key: T; id: T }, | |
| 'key', | |
| 'id' | |
| >; | |
| type RenderItem< | |
| // T extends { keyOrId?: string; [x: string]: any } = { | |
| T extends { keyOrId?: string; [x: string]: unknown } = { | |
| keyOrId: string; | |
| label: string; | |
| }, | |
| > = Prettify< | |
| KeyOrId<T['keyOrId']> & | |
| LabelOrNode<T['label']> & | |
| Omit<T, 'keyOrId' | 'label' | 'children'> | |
| >; | |
| /** Renames keys of an object to a given mapped object. | |
| * | |
| * @example | |
| * ```ts | |
| * type Original = { | |
| * first_name: string; | |
| * last_name: string; | |
| * age: number; | |
| * }; | |
| * type Mapped = RenameKeys<Original, { | |
| * first_name: 'firstName'; | |
| * last_name: 'lastName'; | |
| * }>; | |
| */ | |
| type RemapKeys< | |
| // T extends Record<PropertyKey, any>, | |
| T extends Record<PropertyKey, unknown>, | |
| M extends Partial<Record<keyof T, PropertyKey>>, | |
| > = Prettify<{ | |
| [K in keyof T as K extends keyof M ? M[K] & PropertyKey : K]: T[K]; | |
| }>; | |
| type APIError<E = string> = { success: false; data?: never; error: E }; | |
| type APISuccess<R> = { success: true; data: R; error?: never }; | |
| type APIResponse<R = object, E = string> = APISuccess<R> | APIError<E>; | |
| type PrefixWith<T extends object, P extends string> = { | |
| [K in keyof T as `${P}${Capitalize<string & K>}`]: T[K]; | |
| }; | |
| type FetchOptions = Omit<RequestInit, 'body' | 'method'>; | |
| type Events<T extends Elm = Window> = T extends MediaQueryList | |
| ? MediaQueryListEventMap | |
| : T extends Window | |
| ? WindowEventHandlersEventMap | |
| : T extends Document | |
| ? DocumentEventMap | |
| : T extends MediaQueryList | |
| ? MediaQueryListEventMap | |
| : T extends HTMLElement | Element | |
| ? HTMLElementEventMap | |
| : never; | |
| type EventName<T extends Elm = Window> = keyof Events<T> & string; | |
| type Listeners = { | |
| register: (options?: AddEventListenerOptions | boolean) => void; | |
| unregister: (options?: EventListenerOptions | boolean) => void; | |
| }; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment