106 lines
3.1 KiB
TypeScript
106 lines
3.1 KiB
TypeScript
import { wrap as wrapSync } from "../sync/index.js";
|
|
import { Sequence } from "../sync/types.js";
|
|
import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybePromiseLike } from "../types.js";
|
|
import { isAsyncIterable } from "../utils.js";
|
|
import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence } from "./impl.js";
|
|
import { AsyncSequence } from "./types.js";
|
|
|
|
export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
|
|
return new WrappedSequence(sequence);
|
|
}
|
|
|
|
export function wrap<T>(iterable: MaybeAsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
|
|
if (isAsyncSequence<T>(iterable)) {
|
|
return iterable;
|
|
}
|
|
|
|
if (isAsyncIterable(iterable)) {
|
|
return sequence(iterable);
|
|
}
|
|
|
|
return asAsync(wrapSync(iterable));
|
|
}
|
|
|
|
export function sequence<T>(iterable: AsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
|
|
return new WrappedAsyncIterable(iterable);
|
|
}
|
|
|
|
export function empty<T>(): AsyncSequence<T> {
|
|
return EMPTY;
|
|
}
|
|
|
|
export function single<T>(obj: MaybePromiseLike<T>): AsyncSequence<T> {
|
|
return new WrappedObjectAsync(obj);
|
|
}
|
|
|
|
export function array<T>(array: ReadonlyArray<MaybePromiseLike<T>>): AsyncSequence<T> {
|
|
return new WrappedArrayAsync(array);
|
|
}
|
|
|
|
export function arrayLike<T>(arrayLike: ArrayLike<MaybePromiseLike<T>>): AsyncSequence<T> {
|
|
return new WrappedArrayLikeAsync(arrayLike);
|
|
}
|
|
|
|
export function of<T>(...elements: MaybePromiseLike<T>[]): AsyncSequence<T> {
|
|
switch (elements.length) {
|
|
case 0:
|
|
return empty();
|
|
case 1:
|
|
return single(elements[0]);
|
|
default:
|
|
return array(elements);
|
|
}
|
|
}
|
|
|
|
export function concat<T>(...sequences: AsyncSequence<T>[]): AsyncSequence<T> {
|
|
return new ConcatAsyncSequence<T>(sequences);
|
|
}
|
|
|
|
export function func<T>(f: () => MaybePromiseLike<T>): AsyncSequence<T> {
|
|
return new FunctionAsyncSequence(f);
|
|
}
|
|
|
|
export function generator<T>(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>): AsyncSequence<T> {
|
|
return new GeneratorAsyncSequence(generator);
|
|
}
|
|
|
|
export function range(max: number): AsyncSequence<number>
|
|
export function range(min: number, max: number): AsyncSequence<number>
|
|
export function range(min: number, max: number, step: number): AsyncSequence<number>
|
|
export function range(a: number, b?: number, c?: number): AsyncSequence<number> {
|
|
if (b === undefined) {
|
|
b = a;
|
|
a = 0;
|
|
}
|
|
|
|
if (c === undefined) {
|
|
c = 1;
|
|
}
|
|
|
|
return new RangeAsyncSequence(a, b, c);
|
|
}
|
|
|
|
export function repeat<T>(value: MaybePromiseLike<T>, count?: number): AsyncSequence<T> {
|
|
if (count == undefined) {
|
|
return new RepeatForeverAsyncSequence(value);
|
|
}
|
|
|
|
if (count < 0) {
|
|
throw new Error("count < 0");
|
|
}
|
|
|
|
if (count === 0) {
|
|
return empty();
|
|
}
|
|
|
|
if (count === 1) {
|
|
return new WrappedObjectAsync(value);
|
|
}
|
|
|
|
return new RepeatAsyncSequence(value, count);
|
|
}
|
|
|
|
export function isAsyncSequence<T = any>(obj: any): obj is AsyncSequence<T> {
|
|
return obj instanceof AsyncSequenceMarker;
|
|
}
|