change project structure to remove namespaces
This commit is contained in:
2143
src/async/impl.ts
Normal file
2143
src/async/impl.ts
Normal file
File diff suppressed because it is too large
Load Diff
101
src/async/index.ts
Normal file
101
src/async/index.ts
Normal file
@@ -0,0 +1,101 @@
|
||||
import { wrap as wrapSync } from "../sync/index.js";
|
||||
import { Enumerable } from "../sync/types.js";
|
||||
import { MaybeAsyncIterable } from "../types.js";
|
||||
import { isAsyncIterable } from "../utils.js";
|
||||
import { WrappedEnumerable, WrappedAsyncIterable, EmptyAsyncEnumerable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncEnumerable, GeneratorAsyncEnumerable, RangeAsyncEnumerable, RepeatForeverAsyncEnumerable, RepeatAsyncEnumerable, AsyncEnumerableMarker } from "./impl.js";
|
||||
import { AsyncEnumerable } from "./types.js";
|
||||
|
||||
export function asAsync<T>(enumerable: Enumerable<T>): AsyncEnumerable<T> {
|
||||
return new WrappedEnumerable(enumerable);
|
||||
}
|
||||
|
||||
export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncEnumerable<T> {
|
||||
if (isAsyncEnumerable<T>(iterable)) {
|
||||
return iterable;
|
||||
}
|
||||
|
||||
if (isAsyncIterable(iterable)) {
|
||||
return sequence(iterable);
|
||||
}
|
||||
|
||||
return asAsync(wrapSync(iterable));
|
||||
}
|
||||
|
||||
export function sequence<T>(iterable: AsyncIterable<T>): AsyncEnumerable<T> {
|
||||
return new WrappedAsyncIterable(iterable);
|
||||
}
|
||||
|
||||
export function empty<T>(): AsyncEnumerable<T> {
|
||||
return EmptyAsyncEnumerable.INSTANCE;
|
||||
}
|
||||
|
||||
export function single<T>(obj: T | PromiseLike<T>): AsyncEnumerable<T> {
|
||||
return new WrappedObjectAsync(obj);
|
||||
}
|
||||
|
||||
export function array<T>(array: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
|
||||
return new WrappedArrayAsync(array);
|
||||
}
|
||||
|
||||
export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncEnumerable<T> {
|
||||
return new WrappedArrayLikeAsync(arrayLike);
|
||||
}
|
||||
|
||||
export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
|
||||
switch (elements.length) {
|
||||
case 0:
|
||||
return empty();
|
||||
case 1:
|
||||
return single(elements[0]);
|
||||
default:
|
||||
return array(elements);
|
||||
}
|
||||
}
|
||||
|
||||
export function func<T>(f: () => Promise<T>): AsyncEnumerable<T> {
|
||||
return new FunctionAsyncEnumerable(f);
|
||||
}
|
||||
|
||||
export function generator<T>(generator: () => AsyncGenerator<T>): AsyncEnumerable<T> {
|
||||
return new GeneratorAsyncEnumerable(generator);
|
||||
}
|
||||
|
||||
export function range(max: number): AsyncEnumerable<number>
|
||||
export function range(min: number, max: number): AsyncEnumerable<number>
|
||||
export function range(min: number, max: number, step: number): AsyncEnumerable<number>
|
||||
export function range(a: number, b?: number, c?: number): AsyncEnumerable<number> {
|
||||
if (b === undefined) {
|
||||
b = a;
|
||||
a = 0;
|
||||
}
|
||||
|
||||
if (c === undefined) {
|
||||
c = 1;
|
||||
}
|
||||
|
||||
return new RangeAsyncEnumerable(a, b, c);
|
||||
}
|
||||
|
||||
export function repeat<T>(value: T, count?: number): AsyncEnumerable<T> {
|
||||
if (count == undefined) {
|
||||
return new RepeatForeverAsyncEnumerable(value);
|
||||
}
|
||||
|
||||
if (count < 0) {
|
||||
throw new Error("count < 0");
|
||||
}
|
||||
|
||||
if (count === 0) {
|
||||
return empty();
|
||||
}
|
||||
|
||||
if (count === 1) {
|
||||
return new WrappedObjectAsync(value);
|
||||
}
|
||||
|
||||
return new RepeatAsyncEnumerable(value, count);
|
||||
}
|
||||
|
||||
export function isAsyncEnumerable<T = any>(obj: any): obj is AsyncEnumerable<T> {
|
||||
return obj instanceof AsyncEnumerableMarker;
|
||||
}
|
||||
133
src/async/types.ts
Normal file
133
src/async/types.ts
Normal file
@@ -0,0 +1,133 @@
|
||||
import { Collector } from "../collector/types.js";
|
||||
import { AsyncRandomOptions } from "../random/types.js";
|
||||
import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, Predicate, MaybeAsyncAction } from "../types.js";
|
||||
|
||||
export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElement>> {
|
||||
iterator(): AsyncIterator<Awaited<TElement>>;
|
||||
|
||||
apply<TResult>(pipeline: (enumerable: AsyncEnumerable<TElement>) => TResult): TResult;
|
||||
|
||||
count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>;
|
||||
nonEnumeratedCount(): Promise<number>;
|
||||
fastCount(): Promise<number>;
|
||||
maxCount(): Promise<number>;
|
||||
|
||||
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncEnumerable<TResult>;
|
||||
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncEnumerable<TResult>;
|
||||
|
||||
where(predicate: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
|
||||
|
||||
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TResult>>;
|
||||
|
||||
join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]>;
|
||||
join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult>;
|
||||
|
||||
groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncEnumerable<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult>;
|
||||
|
||||
contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
|
||||
|
||||
sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
|
||||
|
||||
append(obj: TElement): AsyncEnumerable<TElement>;
|
||||
|
||||
prepend(obj: TElement): AsyncEnumerable<TElement>;
|
||||
|
||||
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
|
||||
|
||||
concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncEnumerable<TElement>;
|
||||
|
||||
first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
|
||||
firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
|
||||
|
||||
last(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
|
||||
lastOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
|
||||
|
||||
single(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
|
||||
singleOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
|
||||
|
||||
elementAt(index: number): Promise<TElement>;
|
||||
elementAtOrDefault(index: number, def?: TElement): Promise<TElement | undefined>;
|
||||
|
||||
aggregate(accumulator: MaybeAsyncAccumulator<TElement, TElement>): Promise<TElement>;
|
||||
aggregate<TAccumulator>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator): Promise<TAccumulator>;
|
||||
aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult>): Promise<TResult>;
|
||||
|
||||
min(): Promise<TElement>;
|
||||
minBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
|
||||
|
||||
max(): Promise<TElement>;
|
||||
maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
|
||||
|
||||
order(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>;
|
||||
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>;
|
||||
|
||||
orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>;
|
||||
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>;
|
||||
|
||||
distinct(equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
|
||||
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
|
||||
|
||||
union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
|
||||
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
|
||||
|
||||
except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
|
||||
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
|
||||
|
||||
intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
|
||||
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
|
||||
|
||||
all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
|
||||
any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
|
||||
any(): Promise<boolean>;
|
||||
none(predicate: Predicate<TElement>): Promise<boolean>;
|
||||
none(): Promise<boolean>;
|
||||
|
||||
skip(n: number): AsyncEnumerable<TElement>;
|
||||
skipLast(n: number): AsyncEnumerable<TElement>;
|
||||
skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
|
||||
|
||||
take(n: number): AsyncEnumerable<TElement>;
|
||||
takeLast(n: number): AsyncEnumerable<TElement>;
|
||||
takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
|
||||
|
||||
peek(action: MaybeAsyncAction<TElement>): AsyncEnumerable<TElement>;
|
||||
|
||||
forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
|
||||
|
||||
zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]>;
|
||||
|
||||
indexex(): AsyncEnumerable<[number, Awaited<TElement>]>;
|
||||
|
||||
reversed(): AsyncEnumerable<TElement>;
|
||||
|
||||
chunked(size: number): AsyncEnumerable<TElement[]>;
|
||||
|
||||
random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
|
||||
|
||||
cached(): AsyncEnumerable<TElement>;
|
||||
|
||||
toArray(): Promise<TElement[]>;
|
||||
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
|
||||
toSet(): Promise<Set<TElement>>;
|
||||
toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
|
||||
|
||||
collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;
|
||||
}
|
||||
|
||||
export interface GroupedAsyncEnumerable<TKey, TElement> extends AsyncEnumerable<TElement> {
|
||||
get key(): TKey;
|
||||
}
|
||||
|
||||
export interface OrderedAsyncEnumerable<TElement> extends AsyncEnumerable<TElement> {
|
||||
get comparer(): MaybeAsyncComparer<TElement>;
|
||||
|
||||
thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>;
|
||||
|
||||
thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>;
|
||||
|
||||
thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>;
|
||||
|
||||
thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>;
|
||||
}
|
||||
Reference in New Issue
Block a user