linqx 0.1.8 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -21
- package/README.md +151 -151
- package/dist/linq.d.ts +255 -255
- package/dist/linq.js +3085 -3085
- package/package.json +3 -2
package/dist/linq.d.ts
CHANGED
|
@@ -1,256 +1,256 @@
|
|
|
1
|
-
declare namespace Enumerable {
|
|
2
|
-
export let Utils: {
|
|
3
|
-
createLambda(expression: null): (x: unknown) => unknown;
|
|
4
|
-
createLambda(expression: string): ((...params: unknown[]) => unknown);
|
|
5
|
-
createLambda<T>(expression?: T): T;
|
|
6
|
-
createEnumerable<T>(getEnumerator: () => IEnumerator<T>): IEnumerable<T>;
|
|
7
|
-
createEnumerator<T>(initialize: () => void, tryGetNext: () => boolean, dispose: () => void): IEnumerator<T>;
|
|
8
|
-
extendTo(type: unknown): void;
|
|
9
|
-
recallFrom(type: unknown): void;
|
|
10
|
-
hasNativeIteratorSupport(): boolean;
|
|
11
|
-
}
|
|
12
|
-
|
|
13
|
-
export function choice<T>(...params: T[]): IEnumerable<T>;
|
|
14
|
-
export function cycle<T>(...params: T[]): IEnumerable<T>;
|
|
15
|
-
export function empty<T>(): IEnumerable<T>;
|
|
16
|
-
export function from(): IEnumerable<unknown>;
|
|
17
|
-
export function from<T>(obj: IEnumerable<T>): IEnumerable<T>;
|
|
18
|
-
export function from(obj: number): IEnumerable<number>;
|
|
19
|
-
export function from(obj: boolean): IEnumerable<boolean>;
|
|
20
|
-
export function from(obj: string): IEnumerable<string>;
|
|
21
|
-
export function from<T>(obj: T[]): IEnumerable<T>;
|
|
22
|
-
export function from<T>(obj: Iterator<T>): IEnumerable<T>;
|
|
23
|
-
export function from<T>(obj: Iterable<T>): IEnumerable<T>;
|
|
24
|
-
export function from<T>(obj: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
25
|
-
export function from<K extends PropertyKey, T>(obj: Record<K, T>): IEnumerable<{ key: K; value: T }>;
|
|
26
|
-
export function make<T>(element: T): IEnumerable<T>;
|
|
27
|
-
export function matches<T>(input: string, pattern: RegExp): IEnumerable<T>;
|
|
28
|
-
export function matches<T>(input: string, pattern: string, flags?: string): IEnumerable<T>;
|
|
29
|
-
export function range(start: number, count: number, step?: number): IEnumerable<number>;
|
|
30
|
-
export function rangeDown(start: number, count: number, step?: number): IEnumerable<number>;
|
|
31
|
-
export function rangeTo(start: number, to: number, step?: number): IEnumerable<number>;
|
|
32
|
-
export function repeat<T>(element: T, count?: number): IEnumerable<T>;
|
|
33
|
-
export function repeatWithFinalize<T>(initializer: () => T, finalizer: (element: T) => void): IEnumerable<T>;
|
|
34
|
-
export function generate<T>(func: () => T, count?: number): IEnumerable<T>;
|
|
35
|
-
export function toInfinity(start?: number, step?: number): IEnumerable<number>;
|
|
36
|
-
export function toNegativeInfinity(start?: number, step?: number): IEnumerable<number>;
|
|
37
|
-
export function unfold<T>(seed: T, func: (value: T) => T): IEnumerable<T>;
|
|
38
|
-
export function defer<T>(enumerableFactory: () => IEnumerable<T>): IEnumerable<T>;
|
|
39
|
-
|
|
40
|
-
export interface IEnumerable<T> {
|
|
41
|
-
(getEnumerator: () => IEnumerator<T>): void;
|
|
42
|
-
getEnumerator(): IEnumerator<T>;
|
|
43
|
-
[Symbol.iterator](): Iterator<T>;
|
|
44
|
-
|
|
45
|
-
// Extension Methods
|
|
46
|
-
traverseBreadthFirst(childrenSelector: (element: T) => IEnumerable<T>): IEnumerable<T>;
|
|
47
|
-
traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
|
|
48
|
-
traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
|
|
49
|
-
flatten(): IEnumerable<unknown>;
|
|
50
|
-
pairwise<TResult>(selector: (prev: T, current: T) => TResult): IEnumerable<TResult>;
|
|
51
|
-
scan(func: (prev: T, current: T) => T): IEnumerable<T>;
|
|
52
|
-
scan<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<TAccumulate>;
|
|
53
|
-
select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>;
|
|
54
|
-
selectMany<TOther>(collectionSelector: (element: T, index: number) => IEnumerable<TOther>): IEnumerable<TOther>;
|
|
55
|
-
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => IEnumerable<TCollection>, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
|
56
|
-
selectMany<TOther>(collectionSelector: (element: T, index: number) => TOther[]): IEnumerable<TOther>;
|
|
57
|
-
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => TCollection[], resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
|
58
|
-
selectMany<TOther>(collectionSelector: (element: T, index: number) => { length: number;[x: number]: TOther; }): IEnumerable<TOther>;
|
|
59
|
-
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => { length: number;[x: number]: TCollection; }, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
|
60
|
-
where<TOther extends T>(predicate: (element: T, index: number) => element is TOther): IEnumerable<TOther>;
|
|
61
|
-
where(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
62
|
-
choose(selector: (element: T, index: number) => T): IEnumerable<T>;
|
|
63
|
-
ofType<TResult>(type: unknown): IEnumerable<TResult>;
|
|
64
|
-
zip<U, TResult>(second: IEnumerable<U>, resultSelector: (first: T, second: U, index: number) => TResult): IEnumerable<TResult>;
|
|
65
|
-
zip<U, TResult>(second: { length: number;[x: number]: U; }, resultSelector: (first: T, second: U, index: number) => TResult): IEnumerable<TResult>;
|
|
66
|
-
zip<U, TResult>(second: U[], resultSelector: (first: T, second: U, index: number) => TResult): IEnumerable<TResult>;
|
|
67
|
-
zip<TResult>(...params: unknown[]): IEnumerable<TResult>; // last one is selector
|
|
68
|
-
merge(...params: (T[] | IEnumerable<T> | { length: number;[x: number]: T; })[]): IEnumerable<T>;
|
|
69
|
-
join<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
70
|
-
join<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
71
|
-
join<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
72
|
-
leftJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
73
|
-
leftJoin<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
74
|
-
leftJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
75
|
-
groupJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
76
|
-
groupJoin<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
77
|
-
groupJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
78
|
-
all(predicate: (element: T) => boolean): boolean;
|
|
79
|
-
any(predicate?: (element: T) => boolean): boolean;
|
|
80
|
-
isEmpty(): boolean;
|
|
81
|
-
concat(...sequences: (T[] | IEnumerable<T> | { length: number;[x: number]: T; })[]): IEnumerable<T>;
|
|
82
|
-
insert(index: number, second: IEnumerable<T>): IEnumerable<T>;
|
|
83
|
-
insert(index: number, second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
84
|
-
alternate(alternateValue: T): IEnumerable<T>;
|
|
85
|
-
alternate(alternateSequence: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
86
|
-
alternate(alternateSequence: IEnumerable<T>): IEnumerable<T>;
|
|
87
|
-
alternate(alternateSequence: T[]): IEnumerable<T>;
|
|
88
|
-
contains(value: T): boolean;
|
|
89
|
-
contains<TCompare>(value: T, compareSelector?: (element: T) => TCompare): boolean;
|
|
90
|
-
defaultIfEmpty(defaultValue?: T): IEnumerable<T>;
|
|
91
|
-
distinct(): IEnumerable<T>;
|
|
92
|
-
distinct<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
93
|
-
distinctUntilChanged(): IEnumerable<T>;
|
|
94
|
-
distinctUntilChanged<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
95
|
-
except(second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
96
|
-
except<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
97
|
-
except(second: IEnumerable<T>): IEnumerable<T>;
|
|
98
|
-
except<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
99
|
-
except(second: T[]): IEnumerable<T>;
|
|
100
|
-
except<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
101
|
-
intersect(second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
102
|
-
intersect<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
103
|
-
intersect(second: IEnumerable<T>): IEnumerable<T>;
|
|
104
|
-
intersect<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
105
|
-
intersect(second: T[]): IEnumerable<T>;
|
|
106
|
-
intersect<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
107
|
-
union(second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
108
|
-
union<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
109
|
-
union(second: IEnumerable<T>): IEnumerable<T>;
|
|
110
|
-
union<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
111
|
-
union(second: T[]): IEnumerable<T>;
|
|
112
|
-
union<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
113
|
-
sequenceEqual(second: { length: number;[x: number]: T; }): boolean;
|
|
114
|
-
sequenceEqual<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): boolean;
|
|
115
|
-
sequenceEqual(second: IEnumerable<T>): boolean;
|
|
116
|
-
sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean;
|
|
117
|
-
sequenceEqual(second: T[]): boolean;
|
|
118
|
-
sequenceEqual<TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean;
|
|
119
|
-
orderBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
120
|
-
orderBy<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
121
|
-
orderByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
122
|
-
orderByDescending<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
123
|
-
reverse(): IEnumerable<T>;
|
|
124
|
-
shuffle(): IEnumerable<T>;
|
|
125
|
-
weightedSample(weightSelector: (element: T) => number): IEnumerable<T>;
|
|
126
|
-
groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, T>>;
|
|
127
|
-
groupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>;
|
|
128
|
-
groupBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
|
|
129
|
-
groupBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: TKey) => TCompare): IEnumerable<TResult>;
|
|
130
|
-
partitionBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, unknown>>;
|
|
131
|
-
partitionBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>;
|
|
132
|
-
partitionBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
|
|
133
|
-
partitionBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: TKey) => TCompare): IEnumerable<TResult>;
|
|
134
|
-
buffer(count: number): IEnumerable<T[]>;
|
|
135
|
-
aggregate(func: (prev: T, current: T) => T): T;
|
|
136
|
-
aggregate<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): TAccumulate;
|
|
137
|
-
aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate, resultSelector: (last: TAccumulate) => TResult): TResult;
|
|
138
|
-
average(selector?: (element: T) => number): number;
|
|
139
|
-
count(predicate?: (element: T, index: number) => boolean): number;
|
|
140
|
-
max(selector?: (element: T) => number): number;
|
|
141
|
-
min(selector?: (element: T) => number): number;
|
|
142
|
-
maxBy<TKey>(keySelector: (element: T) => TKey): T;
|
|
143
|
-
minBy<TKey>(keySelector: (element: T) => TKey): T;
|
|
144
|
-
sum(selector?: (element: T) => number): number;
|
|
145
|
-
elementAt(index: number): T;
|
|
146
|
-
elementAtOrDefault(index: number, defaultValue?: T): T | undefined;
|
|
147
|
-
first<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther;
|
|
148
|
-
first(predicate?: (element: T, index: number) => boolean): T;
|
|
149
|
-
firstOrDefault<TOther extends T, TDefault>(predicate: (element: T, index: number) => element is TOther, defaultValue: TDefault): TOther | TDefault;
|
|
150
|
-
firstOrDefault<TDefault>(predicate: (element: T, index: number) => boolean, defaultValue: TDefault): T | TDefault;
|
|
151
|
-
firstOrDefault<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther | undefined;
|
|
152
|
-
firstOrDefault(predicate: (element: T, index: number) => boolean): T | undefined;
|
|
153
|
-
firstOrDefault<TDefault>(defaultValue: TDefault): T | TDefault;
|
|
154
|
-
firstOrDefault(): T | undefined;
|
|
155
|
-
last<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther;
|
|
156
|
-
last(predicate?: (element: T, index: number) => boolean): T;
|
|
157
|
-
lastOrDefault<TOther extends T, TDefault>(predicate: (element: T, index: number) => element is TOther, defaultValue: TDefault): TOther | TDefault;
|
|
158
|
-
lastOrDefault<TDefault>(predicate: (element: T, index: number) => boolean, defaultValue: TDefault): T | TDefault;
|
|
159
|
-
lastOrDefault<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther | undefined;
|
|
160
|
-
lastOrDefault(predicate: (element: T, index: number) => boolean): T | undefined;
|
|
161
|
-
lastOrDefault<TDefault>(defaultValue: TDefault): T | TDefault;
|
|
162
|
-
lastOrDefault(): T | undefined;
|
|
163
|
-
single<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther;
|
|
164
|
-
single(predicate?: (element: T, index: number) => boolean): T;
|
|
165
|
-
singleOrDefault<TOther extends T, TDefault>(predicate: (element: T, index: number) => element is TOther, defaultValue: TDefault): TOther | TDefault;
|
|
166
|
-
singleOrDefault<TDefault>(predicate: (element: T, index: number) => boolean, defaultValue: TDefault): T | TDefault;
|
|
167
|
-
singleOrDefault<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther | undefined;
|
|
168
|
-
singleOrDefault(predicate: (element: T, index: number) => boolean): T | undefined;
|
|
169
|
-
singleOrDefault<TDefault>(defaultValue: TDefault): T | TDefault;
|
|
170
|
-
singleOrDefault(): T | undefined;
|
|
171
|
-
skip(count: number): IEnumerable<T>;
|
|
172
|
-
skipWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
173
|
-
take(count: number): IEnumerable<T>;
|
|
174
|
-
takeWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
175
|
-
takeExceptLast(count?: number): IEnumerable<T>;
|
|
176
|
-
takeFromLast(count: number): IEnumerable<T>;
|
|
177
|
-
indexOf(item: T): number;
|
|
178
|
-
indexOf(predicate: (element: T, index: number) => boolean): number;
|
|
179
|
-
lastIndexOf(item: T): number;
|
|
180
|
-
lastIndexOf(predicate: (element: T, index: number) => boolean): number;
|
|
181
|
-
asEnumerable(): IEnumerable<T>;
|
|
182
|
-
cast<TResult>(): IEnumerable<TResult>;
|
|
183
|
-
toArray(): T[];
|
|
184
|
-
toLookup<TKey>(keySelector: (element: T) => TKey): ILookup<TKey, T>;
|
|
185
|
-
toLookup<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): ILookup<TKey, TElement>;
|
|
186
|
-
toLookup<TKey, TElement, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, compareSelector: (key: TKey) => TCompare): ILookup<TKey, TElement>;
|
|
187
|
-
toObject<TKey extends PropertyKey, TElement>(keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement): Record<TKey, TElement>;
|
|
188
|
-
toDictionary<TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, T>;
|
|
189
|
-
toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>;
|
|
190
|
-
toDictionary<TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>;
|
|
191
|
-
toJSONString(replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
|
|
192
|
-
toJSONString(replacer?: (string | number)[], space?: string | number): string;
|
|
193
|
-
toJoinedString(separator?: string): string;
|
|
194
|
-
toJoinedString<TResult>(separator: string, selector: (element: T, index: number) => TResult): string;
|
|
195
|
-
doAction(action: (element: T, index: number) => void): IEnumerable<T>;
|
|
196
|
-
doAction(action: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
197
|
-
forEach(action: (element: T, index: number) => void): void;
|
|
198
|
-
forEach(action: (element: T, index: number) => boolean): void;
|
|
199
|
-
force(): void;
|
|
200
|
-
letBind<TResult>(func: (source: IEnumerable<T>) => { length: number;[x: number]: TResult; }): IEnumerable<TResult>;
|
|
201
|
-
letBind<TResult>(func: (source: IEnumerable<T>) => TResult[]): IEnumerable<TResult>;
|
|
202
|
-
letBind<TResult>(func: (source: IEnumerable<T>) => IEnumerable<TResult>): IEnumerable<TResult>;
|
|
203
|
-
share(): IDisposableEnumerable<T>;
|
|
204
|
-
memoize(): IDisposableEnumerable<T>;
|
|
205
|
-
catchError(handler: string | ((exception: unknown) => void)): IEnumerable<T>;
|
|
206
|
-
finallyAction(finallyAction: () => void): IEnumerable<T>;
|
|
207
|
-
log(): IEnumerable<T>;
|
|
208
|
-
log<TValue>(selector: (element: T) => TValue): IEnumerable<T>;
|
|
209
|
-
trace(message?: string): IEnumerable<T>;
|
|
210
|
-
trace<TValue>(message: string, selector: (element: T) => TValue): IEnumerable<T>;
|
|
211
|
-
}
|
|
212
|
-
|
|
213
|
-
export interface IEnumerator<T> {
|
|
214
|
-
current(): T;
|
|
215
|
-
moveNext(): boolean;
|
|
216
|
-
dispose(): void;
|
|
217
|
-
}
|
|
218
|
-
|
|
219
|
-
export interface IOrderedEnumerable<T> extends IEnumerable<T> {
|
|
220
|
-
createOrderedEnumerable<TKey>(keySelector: (element: T) => TKey, comparer?: (first: TKey, second: TKey) => number, descending?: boolean): IOrderedEnumerable<T>;
|
|
221
|
-
thenBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
222
|
-
thenBy<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
223
|
-
thenByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
224
|
-
thenByDescending<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
225
|
-
}
|
|
226
|
-
|
|
227
|
-
export interface IDisposableEnumerable<T> extends IEnumerable<T> {
|
|
228
|
-
dispose(): void;
|
|
229
|
-
}
|
|
230
|
-
|
|
231
|
-
export interface IDictionary<TKey, TValue> {
|
|
232
|
-
add(key: TKey, value: TValue): void;
|
|
233
|
-
get(key: TKey): TValue;
|
|
234
|
-
set(key: TKey, value: TValue): boolean;
|
|
235
|
-
contains(key: TKey): boolean;
|
|
236
|
-
clear(): void;
|
|
237
|
-
remove(key: TKey): void;
|
|
238
|
-
count(): number;
|
|
239
|
-
toEnumerable(): IEnumerable<{ key: TKey; value: TValue }>;
|
|
240
|
-
}
|
|
241
|
-
|
|
242
|
-
export interface ILookup<TKey, TElement> {
|
|
243
|
-
count(): number;
|
|
244
|
-
get(key: TKey): IEnumerable<TElement>;
|
|
245
|
-
contains(key: TKey): boolean;
|
|
246
|
-
toEnumerable(): IEnumerable<IGrouping<TKey, TElement>>;
|
|
247
|
-
}
|
|
248
|
-
|
|
249
|
-
export interface IGrouping<TKey, TElement> extends IEnumerable<TElement> {
|
|
250
|
-
key(): TKey;
|
|
251
|
-
getSource(): TElement[];
|
|
252
|
-
}
|
|
253
|
-
}
|
|
254
|
-
|
|
255
|
-
export default Enumerable;
|
|
1
|
+
declare namespace Enumerable {
|
|
2
|
+
export let Utils: {
|
|
3
|
+
createLambda(expression: null): (x: unknown) => unknown;
|
|
4
|
+
createLambda(expression: string): ((...params: unknown[]) => unknown);
|
|
5
|
+
createLambda<T>(expression?: T): T;
|
|
6
|
+
createEnumerable<T>(getEnumerator: () => IEnumerator<T>): IEnumerable<T>;
|
|
7
|
+
createEnumerator<T>(initialize: () => void, tryGetNext: () => boolean, dispose: () => void): IEnumerator<T>;
|
|
8
|
+
extendTo(type: unknown): void;
|
|
9
|
+
recallFrom(type: unknown): void;
|
|
10
|
+
hasNativeIteratorSupport(): boolean;
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
export function choice<T>(...params: T[]): IEnumerable<T>;
|
|
14
|
+
export function cycle<T>(...params: T[]): IEnumerable<T>;
|
|
15
|
+
export function empty<T>(): IEnumerable<T>;
|
|
16
|
+
export function from(): IEnumerable<unknown>;
|
|
17
|
+
export function from<T>(obj: IEnumerable<T>): IEnumerable<T>;
|
|
18
|
+
export function from(obj: number): IEnumerable<number>;
|
|
19
|
+
export function from(obj: boolean): IEnumerable<boolean>;
|
|
20
|
+
export function from(obj: string): IEnumerable<string>;
|
|
21
|
+
export function from<T>(obj: T[]): IEnumerable<T>;
|
|
22
|
+
export function from<T>(obj: Iterator<T>): IEnumerable<T>;
|
|
23
|
+
export function from<T>(obj: Iterable<T>): IEnumerable<T>;
|
|
24
|
+
export function from<T>(obj: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
25
|
+
export function from<K extends PropertyKey, T>(obj: Record<K, T>): IEnumerable<{ key: K; value: T }>;
|
|
26
|
+
export function make<T>(element: T): IEnumerable<T>;
|
|
27
|
+
export function matches<T>(input: string, pattern: RegExp): IEnumerable<T>;
|
|
28
|
+
export function matches<T>(input: string, pattern: string, flags?: string): IEnumerable<T>;
|
|
29
|
+
export function range(start: number, count: number, step?: number): IEnumerable<number>;
|
|
30
|
+
export function rangeDown(start: number, count: number, step?: number): IEnumerable<number>;
|
|
31
|
+
export function rangeTo(start: number, to: number, step?: number): IEnumerable<number>;
|
|
32
|
+
export function repeat<T>(element: T, count?: number): IEnumerable<T>;
|
|
33
|
+
export function repeatWithFinalize<T>(initializer: () => T, finalizer: (element: T) => void): IEnumerable<T>;
|
|
34
|
+
export function generate<T>(func: () => T, count?: number): IEnumerable<T>;
|
|
35
|
+
export function toInfinity(start?: number, step?: number): IEnumerable<number>;
|
|
36
|
+
export function toNegativeInfinity(start?: number, step?: number): IEnumerable<number>;
|
|
37
|
+
export function unfold<T>(seed: T, func: (value: T) => T): IEnumerable<T>;
|
|
38
|
+
export function defer<T>(enumerableFactory: () => IEnumerable<T>): IEnumerable<T>;
|
|
39
|
+
|
|
40
|
+
export interface IEnumerable<T> {
|
|
41
|
+
(getEnumerator: () => IEnumerator<T>): void;
|
|
42
|
+
getEnumerator(): IEnumerator<T>;
|
|
43
|
+
[Symbol.iterator](): Iterator<T>;
|
|
44
|
+
|
|
45
|
+
// Extension Methods
|
|
46
|
+
traverseBreadthFirst(childrenSelector: (element: T) => IEnumerable<T>): IEnumerable<T>;
|
|
47
|
+
traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
|
|
48
|
+
traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
|
|
49
|
+
flatten(): IEnumerable<unknown>;
|
|
50
|
+
pairwise<TResult>(selector: (prev: T, current: T) => TResult): IEnumerable<TResult>;
|
|
51
|
+
scan(func: (prev: T, current: T) => T): IEnumerable<T>;
|
|
52
|
+
scan<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<TAccumulate>;
|
|
53
|
+
select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>;
|
|
54
|
+
selectMany<TOther>(collectionSelector: (element: T, index: number) => IEnumerable<TOther>): IEnumerable<TOther>;
|
|
55
|
+
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => IEnumerable<TCollection>, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
|
56
|
+
selectMany<TOther>(collectionSelector: (element: T, index: number) => TOther[]): IEnumerable<TOther>;
|
|
57
|
+
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => TCollection[], resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
|
58
|
+
selectMany<TOther>(collectionSelector: (element: T, index: number) => { length: number;[x: number]: TOther; }): IEnumerable<TOther>;
|
|
59
|
+
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => { length: number;[x: number]: TCollection; }, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
|
60
|
+
where<TOther extends T>(predicate: (element: T, index: number) => element is TOther): IEnumerable<TOther>;
|
|
61
|
+
where(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
62
|
+
choose(selector: (element: T, index: number) => T): IEnumerable<T>;
|
|
63
|
+
ofType<TResult>(type: unknown): IEnumerable<TResult>;
|
|
64
|
+
zip<U, TResult>(second: IEnumerable<U>, resultSelector: (first: T, second: U, index: number) => TResult): IEnumerable<TResult>;
|
|
65
|
+
zip<U, TResult>(second: { length: number;[x: number]: U; }, resultSelector: (first: T, second: U, index: number) => TResult): IEnumerable<TResult>;
|
|
66
|
+
zip<U, TResult>(second: U[], resultSelector: (first: T, second: U, index: number) => TResult): IEnumerable<TResult>;
|
|
67
|
+
zip<TResult>(...params: unknown[]): IEnumerable<TResult>; // last one is selector
|
|
68
|
+
merge(...params: (T[] | IEnumerable<T> | { length: number;[x: number]: T; })[]): IEnumerable<T>;
|
|
69
|
+
join<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
70
|
+
join<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
71
|
+
join<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
72
|
+
leftJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
73
|
+
leftJoin<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
74
|
+
leftJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
75
|
+
groupJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
76
|
+
groupJoin<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
77
|
+
groupJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
|
78
|
+
all(predicate: (element: T) => boolean): boolean;
|
|
79
|
+
any(predicate?: (element: T) => boolean): boolean;
|
|
80
|
+
isEmpty(): boolean;
|
|
81
|
+
concat(...sequences: (T[] | IEnumerable<T> | { length: number;[x: number]: T; })[]): IEnumerable<T>;
|
|
82
|
+
insert(index: number, second: IEnumerable<T>): IEnumerable<T>;
|
|
83
|
+
insert(index: number, second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
84
|
+
alternate(alternateValue: T): IEnumerable<T>;
|
|
85
|
+
alternate(alternateSequence: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
86
|
+
alternate(alternateSequence: IEnumerable<T>): IEnumerable<T>;
|
|
87
|
+
alternate(alternateSequence: T[]): IEnumerable<T>;
|
|
88
|
+
contains(value: T): boolean;
|
|
89
|
+
contains<TCompare>(value: T, compareSelector?: (element: T) => TCompare): boolean;
|
|
90
|
+
defaultIfEmpty(defaultValue?: T): IEnumerable<T>;
|
|
91
|
+
distinct(): IEnumerable<T>;
|
|
92
|
+
distinct<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
93
|
+
distinctUntilChanged(): IEnumerable<T>;
|
|
94
|
+
distinctUntilChanged<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
95
|
+
except(second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
96
|
+
except<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
97
|
+
except(second: IEnumerable<T>): IEnumerable<T>;
|
|
98
|
+
except<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
99
|
+
except(second: T[]): IEnumerable<T>;
|
|
100
|
+
except<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
101
|
+
intersect(second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
102
|
+
intersect<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
103
|
+
intersect(second: IEnumerable<T>): IEnumerable<T>;
|
|
104
|
+
intersect<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
105
|
+
intersect(second: T[]): IEnumerable<T>;
|
|
106
|
+
intersect<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
107
|
+
union(second: { length: number;[x: number]: T; }): IEnumerable<T>;
|
|
108
|
+
union<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
109
|
+
union(second: IEnumerable<T>): IEnumerable<T>;
|
|
110
|
+
union<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
111
|
+
union(second: T[]): IEnumerable<T>;
|
|
112
|
+
union<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
|
113
|
+
sequenceEqual(second: { length: number;[x: number]: T; }): boolean;
|
|
114
|
+
sequenceEqual<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): boolean;
|
|
115
|
+
sequenceEqual(second: IEnumerable<T>): boolean;
|
|
116
|
+
sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean;
|
|
117
|
+
sequenceEqual(second: T[]): boolean;
|
|
118
|
+
sequenceEqual<TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean;
|
|
119
|
+
orderBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
120
|
+
orderBy<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
121
|
+
orderByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
122
|
+
orderByDescending<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
123
|
+
reverse(): IEnumerable<T>;
|
|
124
|
+
shuffle(): IEnumerable<T>;
|
|
125
|
+
weightedSample(weightSelector: (element: T) => number): IEnumerable<T>;
|
|
126
|
+
groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, T>>;
|
|
127
|
+
groupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>;
|
|
128
|
+
groupBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
|
|
129
|
+
groupBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: TKey) => TCompare): IEnumerable<TResult>;
|
|
130
|
+
partitionBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, unknown>>;
|
|
131
|
+
partitionBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>;
|
|
132
|
+
partitionBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
|
|
133
|
+
partitionBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: TKey) => TCompare): IEnumerable<TResult>;
|
|
134
|
+
buffer(count: number): IEnumerable<T[]>;
|
|
135
|
+
aggregate(func: (prev: T, current: T) => T): T;
|
|
136
|
+
aggregate<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): TAccumulate;
|
|
137
|
+
aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate, resultSelector: (last: TAccumulate) => TResult): TResult;
|
|
138
|
+
average(selector?: (element: T) => number): number;
|
|
139
|
+
count(predicate?: (element: T, index: number) => boolean): number;
|
|
140
|
+
max(selector?: (element: T) => number): number;
|
|
141
|
+
min(selector?: (element: T) => number): number;
|
|
142
|
+
maxBy<TKey>(keySelector: (element: T) => TKey): T;
|
|
143
|
+
minBy<TKey>(keySelector: (element: T) => TKey): T;
|
|
144
|
+
sum(selector?: (element: T) => number): number;
|
|
145
|
+
elementAt(index: number): T;
|
|
146
|
+
elementAtOrDefault(index: number, defaultValue?: T): T | undefined;
|
|
147
|
+
first<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther;
|
|
148
|
+
first(predicate?: (element: T, index: number) => boolean): T;
|
|
149
|
+
firstOrDefault<TOther extends T, TDefault>(predicate: (element: T, index: number) => element is TOther, defaultValue: TDefault): TOther | TDefault;
|
|
150
|
+
firstOrDefault<TDefault>(predicate: (element: T, index: number) => boolean, defaultValue: TDefault): T | TDefault;
|
|
151
|
+
firstOrDefault<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther | undefined;
|
|
152
|
+
firstOrDefault(predicate: (element: T, index: number) => boolean): T | undefined;
|
|
153
|
+
firstOrDefault<TDefault>(defaultValue: TDefault): T | TDefault;
|
|
154
|
+
firstOrDefault(): T | undefined;
|
|
155
|
+
last<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther;
|
|
156
|
+
last(predicate?: (element: T, index: number) => boolean): T;
|
|
157
|
+
lastOrDefault<TOther extends T, TDefault>(predicate: (element: T, index: number) => element is TOther, defaultValue: TDefault): TOther | TDefault;
|
|
158
|
+
lastOrDefault<TDefault>(predicate: (element: T, index: number) => boolean, defaultValue: TDefault): T | TDefault;
|
|
159
|
+
lastOrDefault<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther | undefined;
|
|
160
|
+
lastOrDefault(predicate: (element: T, index: number) => boolean): T | undefined;
|
|
161
|
+
lastOrDefault<TDefault>(defaultValue: TDefault): T | TDefault;
|
|
162
|
+
lastOrDefault(): T | undefined;
|
|
163
|
+
single<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther;
|
|
164
|
+
single(predicate?: (element: T, index: number) => boolean): T;
|
|
165
|
+
singleOrDefault<TOther extends T, TDefault>(predicate: (element: T, index: number) => element is TOther, defaultValue: TDefault): TOther | TDefault;
|
|
166
|
+
singleOrDefault<TDefault>(predicate: (element: T, index: number) => boolean, defaultValue: TDefault): T | TDefault;
|
|
167
|
+
singleOrDefault<TOther extends T>(predicate: (element: T, index: number) => element is TOther): TOther | undefined;
|
|
168
|
+
singleOrDefault(predicate: (element: T, index: number) => boolean): T | undefined;
|
|
169
|
+
singleOrDefault<TDefault>(defaultValue: TDefault): T | TDefault;
|
|
170
|
+
singleOrDefault(): T | undefined;
|
|
171
|
+
skip(count: number): IEnumerable<T>;
|
|
172
|
+
skipWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
173
|
+
take(count: number): IEnumerable<T>;
|
|
174
|
+
takeWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
175
|
+
takeExceptLast(count?: number): IEnumerable<T>;
|
|
176
|
+
takeFromLast(count: number): IEnumerable<T>;
|
|
177
|
+
indexOf(item: T): number;
|
|
178
|
+
indexOf(predicate: (element: T, index: number) => boolean): number;
|
|
179
|
+
lastIndexOf(item: T): number;
|
|
180
|
+
lastIndexOf(predicate: (element: T, index: number) => boolean): number;
|
|
181
|
+
asEnumerable(): IEnumerable<T>;
|
|
182
|
+
cast<TResult>(): IEnumerable<TResult>;
|
|
183
|
+
toArray(): T[];
|
|
184
|
+
toLookup<TKey>(keySelector: (element: T) => TKey): ILookup<TKey, T>;
|
|
185
|
+
toLookup<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): ILookup<TKey, TElement>;
|
|
186
|
+
toLookup<TKey, TElement, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, compareSelector: (key: TKey) => TCompare): ILookup<TKey, TElement>;
|
|
187
|
+
toObject<TKey extends PropertyKey, TElement>(keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement): Record<TKey, TElement>;
|
|
188
|
+
toDictionary<TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, T>;
|
|
189
|
+
toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>;
|
|
190
|
+
toDictionary<TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>;
|
|
191
|
+
toJSONString(replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
|
|
192
|
+
toJSONString(replacer?: (string | number)[], space?: string | number): string;
|
|
193
|
+
toJoinedString(separator?: string): string;
|
|
194
|
+
toJoinedString<TResult>(separator: string, selector: (element: T, index: number) => TResult): string;
|
|
195
|
+
doAction(action: (element: T, index: number) => void): IEnumerable<T>;
|
|
196
|
+
doAction(action: (element: T, index: number) => boolean): IEnumerable<T>;
|
|
197
|
+
forEach(action: (element: T, index: number) => void): void;
|
|
198
|
+
forEach(action: (element: T, index: number) => boolean): void;
|
|
199
|
+
force(): void;
|
|
200
|
+
letBind<TResult>(func: (source: IEnumerable<T>) => { length: number;[x: number]: TResult; }): IEnumerable<TResult>;
|
|
201
|
+
letBind<TResult>(func: (source: IEnumerable<T>) => TResult[]): IEnumerable<TResult>;
|
|
202
|
+
letBind<TResult>(func: (source: IEnumerable<T>) => IEnumerable<TResult>): IEnumerable<TResult>;
|
|
203
|
+
share(): IDisposableEnumerable<T>;
|
|
204
|
+
memoize(): IDisposableEnumerable<T>;
|
|
205
|
+
catchError(handler: string | ((exception: unknown) => void)): IEnumerable<T>;
|
|
206
|
+
finallyAction(finallyAction: () => void): IEnumerable<T>;
|
|
207
|
+
log(): IEnumerable<T>;
|
|
208
|
+
log<TValue>(selector: (element: T) => TValue): IEnumerable<T>;
|
|
209
|
+
trace(message?: string): IEnumerable<T>;
|
|
210
|
+
trace<TValue>(message: string, selector: (element: T) => TValue): IEnumerable<T>;
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
export interface IEnumerator<T> {
|
|
214
|
+
current(): T;
|
|
215
|
+
moveNext(): boolean;
|
|
216
|
+
dispose(): void;
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
export interface IOrderedEnumerable<T> extends IEnumerable<T> {
|
|
220
|
+
createOrderedEnumerable<TKey>(keySelector: (element: T) => TKey, comparer?: (first: TKey, second: TKey) => number, descending?: boolean): IOrderedEnumerable<T>;
|
|
221
|
+
thenBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
222
|
+
thenBy<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
223
|
+
thenByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
|
224
|
+
thenByDescending<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>;
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
export interface IDisposableEnumerable<T> extends IEnumerable<T> {
|
|
228
|
+
dispose(): void;
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
export interface IDictionary<TKey, TValue> {
|
|
232
|
+
add(key: TKey, value: TValue): void;
|
|
233
|
+
get(key: TKey): TValue;
|
|
234
|
+
set(key: TKey, value: TValue): boolean;
|
|
235
|
+
contains(key: TKey): boolean;
|
|
236
|
+
clear(): void;
|
|
237
|
+
remove(key: TKey): void;
|
|
238
|
+
count(): number;
|
|
239
|
+
toEnumerable(): IEnumerable<{ key: TKey; value: TValue }>;
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
export interface ILookup<TKey, TElement> {
|
|
243
|
+
count(): number;
|
|
244
|
+
get(key: TKey): IEnumerable<TElement>;
|
|
245
|
+
contains(key: TKey): boolean;
|
|
246
|
+
toEnumerable(): IEnumerable<IGrouping<TKey, TElement>>;
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
export interface IGrouping<TKey, TElement> extends IEnumerable<TElement> {
|
|
250
|
+
key(): TKey;
|
|
251
|
+
getSource(): TElement[];
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
export default Enumerable;
|
|
256
256
|
export { Enumerable };
|