Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 | export type DeepPartial<T> = T extends object
? { [P in keyof T]?: DeepPartial<T[P]> }
: T;
export type OmitDeep<T, TerminalVaue, K extends PropertyKey> = T extends
| string
| number
| symbol
| bigint
| boolean
| null
| undefined
// oxlint-disable-next-line typescript/no-unsafe-function-type typescript/ban-types
| Function
| TerminalVaue
? T
: T extends (infer U)[]
? OmitDeep<U, TerminalVaue, K>[]
: T extends object
? {
[P in keyof T as P extends K ? never : P]: OmitDeep<
T[P],
TerminalVaue,
K
>;
}
: T;
export type SplitStringByComma<S extends string> =
S extends `${infer SS}.${infer SSS}` ? [SS, ...SplitStringByComma<SSS>] : [S];
type ExtractObj<S extends object, K> = K extends keyof S ? S[K] : never;
export type ExtractObjectByPath<
S extends object,
T extends unknown[],
> = T extends [infer T0, ...infer TR]
? TR extends []
? ExtractObj<S, T0> extends never
? never
: ExtractObj<S, T0>
: ExtractObj<S, T0> extends object
? ExtractObjectByPath<ExtractObj<S, T0>, TR>
: ExtractObj<S, T0> extends never
? never
: ExtractObj<S, T0>
: never;
// https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type/50375286#50375286
export type UnionToIntersection<U> = (
U extends unknown ? (k: U) => void : never
) extends (k: infer I) => void
? I
: never;
export type FlattenObject<
Terminator,
T extends Record<string, unknown>,
PrevKey extends string = "",
Key = keyof T,
> = Key extends string
? T[Key] extends never
? never
: T[Key] extends Terminator
? Record<PrevKey extends "" ? `${Key}` : `${PrevKey}.${Key}`, T[Key]>
: T[Key] extends Record<string, unknown>
? FlattenObject<
Terminator,
T[Key],
PrevKey extends "" ? `${Key}` : `${PrevKey}.${Key}`
>
: never
: never;
export type Exact<A, B> =
(<T>() => T extends A ? 1 : 0) extends <T>() => T extends B ? 1 : 0
? A extends B
? B extends A
? unknown
: never
: never
: never;
export type MaybeAddElementToArray<Args extends unknown[], X = undefined> =
Exact<X, undefined> extends never
? X extends undefined
? [...Args, X?]
: [...Args, X]
: Args;
export type KeysMatching<T extends object, V> = {
[K in keyof T]-?: T[K] extends V ? K : never;
}[keyof T];
export type AddParameters<
// oxlint-disable-next-line typescript/no-explicit-any
Fn extends (...args: any) => unknown,
AddedParameters extends [...args: unknown[]],
> = (...args: [...Parameters<Fn>, ...AddedParameters]) => ReturnType<Fn>;
export type Tail<T extends unknown[]> = T extends [unknown, ...infer R]
? R
: never;
type MaybeUndefinedProps<T extends object> = {
[K in keyof T as undefined extends T[K] ? K : never]?: T[K];
};
export type MakeUndefinedOptional<T extends object> = MaybeUndefinedProps<T> &
Omit<T, keyof MaybeUndefinedProps<T>>;
export type TupleOf<T, N extends number> = N extends N
? number extends N
? T[]
: InnerTupleOf<T, N, []>
: never;
type InnerTupleOf<
T,
N extends number,
R extends unknown[],
> = R["length"] extends N ? R : InnerTupleOf<T, N, [T, ...R]>;
export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
type NullableObject<T> =
| {
[K in keyof T]: T[K];
}
| {
[K in keyof T]: null;
};
export type MappedNullableObject<
T,
KeyMapping extends Record<string, keyof T>,
> = NullableObject<{
[K in keyof KeyMapping]: T[KeyMapping[K]];
}>;
export type MaybePromise<T> = T | Promise<T>;
type Equals<X, Y> =
(<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
? true
: false;
type AssertTrue<A extends true, X> = A extends true ? X : never;
type AllEqual<T extends unknown[]> = T extends [infer A, infer B, ...infer Rest]
? Equals<A, B> extends true
? AllEqual<[B, ...Rest]>
: false
: true;
export type AssertAllEqual<T extends unknown[]> = AssertTrue<
AllEqual<T>,
T extends (infer U)[] ? U : never
>;
export type ArrayOf<T extends unknown[]> = {
[K in keyof T]: [T[K], ...T[K][]];
};
|