-
Notifications
You must be signed in to change notification settings - Fork 0
/
types.ts
169 lines (138 loc) · 6.89 KB
/
types.ts
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
164
165
166
167
168
169
export type IteratorOrIterable<T> = Iterator<T> | Iterable<T>;
// export type AsyncIteratorOrIterable<T> = AsyncIterator<T> | AsyncIterable<T>;
export type FlattenDeep<A> =
A extends IteratorOrIterable<infer B>
? B extends IteratorOrIterable<infer C>
? C extends IteratorOrIterable<infer D>
? D extends IteratorOrIterable<infer E>
? E extends IteratorOrIterable<infer F>
? F extends IteratorOrIterable<infer G>
? G extends IteratorOrIterable<infer H>
? H extends IteratorOrIterable<infer I>
? I extends IteratorOrIterable<infer J>
? J
: I
: H
: G
: F
: E
: D
: C
: B
: A;
// export type AsyncFlattenDeep<T> = T extends AsyncIteratorOrIterable<infer V>
// ? V extends AsyncIteratorOrIterable<infer U>
// ? U
// : V
// : T;
export type FlattenDepth1<T> = T extends IteratorOrIterable<infer V> ? V : T;
export type FlattenDepth2<T> = T extends IteratorOrIterable<infer V> ? FlattenDepth1<V> : T;
export type FlattenDepth3<T> = T extends IteratorOrIterable<infer V> ? FlattenDepth2<V> : T;
export type FlattenDepth4<T> = T extends IteratorOrIterable<infer V> ? FlattenDepth3<V> : T;
export type FlattenDepth5<T> = T extends IteratorOrIterable<infer V> ? FlattenDepth4<V> : T;
// export type AsyncFlattenDepth1<T> = T extends AsyncIteratorOrIterable<infer V> ? V : T;
// export type AsyncFlattenDepth2<T> = T extends AsyncIteratorOrIterable<infer V> ? AsyncFlattenDepth1<V> : T;
// export type AsyncFlattenDepth3<T> = T extends AsyncIteratorOrIterable<infer V> ? AsyncFlattenDepth2<V> : T;
// export type AsyncFlattenDepth4<T> = T extends AsyncIteratorOrIterable<infer V> ? AsyncFlattenDepth3<V> : T;
// export type AsyncFlattenDepth5<T> = T extends AsyncIteratorOrIterable<infer V> ? AsyncFlattenDepth4<V> : T;
type TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : TupleOf<T, N, [T, ...R]>;
type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N
? Acc[number]
: Enumerate<N, [...Acc, Acc['length']]>;
/** Creates a union of all integers between `StartInclusive` and `EndExclusive`. */
export type IntRange<StartInclusive extends number, EndExclusive extends number> = Exclude<
Enumerate<EndExclusive>,
Enumerate<StartInclusive>
>;
/**
* Creates a tuple of `T` and size `N` which is unconstrained by size of `N`. So for large tuples the
* "Type instantiation is excessively deep and possibly infinite" TS error will occur.
*/
export type UnconstrainedTuple<T, N extends number> = N extends N
? number extends N
? T[]
: TupleOf<T, N, []>
: never;
export type Tuple<T, N extends number, Range extends number = IntRange<0, 11>> = N extends Range
? UnconstrainedTuple<T, N>
: T[];
// type a = Tuple<number, 0>;
// // ^?
// type b = Tuple<number, 10>;
// // ^?
// type c = Tuple<number, 11>;
// // ^?
/** A function that returns a truthy or falsey value given an input value of type `T`. */
export type Predicate<T> = (value: T) => unknown;
/** A function that returns a truthy or falsey value that determines if `T` is `S`. */
export type StrictPredicate<T, S extends T> = (value: T) => value is S;
// /** An async function that returns a truthy or falsey value given an input value of type `T`. */
// export type AsyncPredicate<T> = (value: T) => Promise<any>;
/** A function designated as a callback which doesn't necessarily return anything. */
export type Callback<T, R = unknown> = (value: T) => R;
// /** An async function designated as a callback which doesn't necessarily return anything. */
// export type AsyncCallback<T, R = any> = (value: T) => Promise<R>;
/** A function that does something with value of type `T` and transforms it into type `R`. */
export type Iteratee<T, R> = (value: T) => R;
// /** An async function that does something with value of type `T` and transforms it into type `R`. */
// export type AsyncIteratee<T, R> = (value: T) => Promise<R>;
/** Any generic function. */
export interface Fn<Args extends any[] = any[], Result = any> {
(...args: Args): Result;
}
/** Returns the source of the generic Iterable, Iterator, IterableIterator or their async counterparts. */
export type IterSource<T> =
T extends Iterable<infer U>
? U
: T extends Iterator<infer U>
? U
: T extends IterableIterator<infer U>
? U
: T extends AsyncIterable<infer U>
? U
: T extends AsyncIterator<infer U>
? U
: T extends AsyncIterableIterator<infer U>
? U
: T;
export type MapToSource<T extends IteratorOrIterable<any>[]> = {
[K in keyof T]: IterSource<T[K]>;
};
// export type ObjectLeafs<T extends Record<string, unknown>, K = keyof T> = K extends string
// ? T[K] extends Record<string, unknown>
// ? ObjectLeafs<T[K], keyof T[K]>
// : [K, T[K]]
// : T;
// export type ObjectBranches<T extends Record<string, unknown>, K = keyof T> = K extends string
// ? T[K] extends Record<string, unknown>
// ? [K, T[K]] | ObjectBranches<T[K], keyof T[K]>
// : never
// : T;
// export type ObjectEntries<T extends Record<string, unknown>> = ObjectLeafs<T> | ObjectBranches<T>;
/** A tuple representing the key, value and parent object (in that order) of an entry/key-value pair in an object. */
export type ObjectEntry<T = any> = [string, T, any];
/** Recursively unwraps `T` until it's not a Promise, (Polyfill) */
export type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;
export type KeyIdentifier<T> = keyof T | Iteratee<T, any>;
export type KeyIdentifiersValue<T, K extends KeyIdentifier<T>> = K extends keyof T
? T[K]
: K extends Iteratee<T, any>
? ReturnType<K>
: never;
/** The params used for `unique` method/function. */
export type UniqueParams<T> = { iteratee?: Iteratee<T, any>; justSeen?: boolean } | Iteratee<T, any>;
export type ShiftArr<T extends unknown[]> = T extends [unknown, ...infer P] ? P : never;
export type ItOrCurriedIt<T> = IterableIterator<T> | ((arg: IteratorOrIterable<T>) => IterableIterator<T>);
// export interface Curry1<T extends Fn> {
// (...args: Parameters<T>): ReturnType<T>;
// (...args: ShiftArr<Parameters<T>>): (arg0: Parameters<T>[0]) => ReturnType<T>;
// // (...args: ParametersExceptFirst<ParametersExceptFirst<T>>): (
// // arg0: Parameters<T>[0],
// // ) => (arg1: Parameters<T>[1]) => ReturnType<T>;
// // (...args: ParametersExceptFirst<ParametersExceptFirst<ParametersExceptFirst<T>>>): (
// // arg0: Parameters<T>[0],
// // ) => (arg1: Parameters<T>[1]) => (arg2: Parameters<T>[2]) => ReturnType<T>;
// // (...args: ParametersExceptFirst<ParametersExceptFirst<ParametersExceptFirst<ParametersExceptFirst<T>>>>): (
// // arg0: Parameters<T>[0],
// // ) => (arg1: Parameters<T>[1]) => (arg2: Parameters<T>[2]) => (arg3: Parameters<T>[3]) => ReturnType<T>;
// }