gingersnap 0.22.0

package/stream.mjs

@@ -0,0 +1,1132 @@
+import { __awaiter, __asyncValues } from './_virtual/_tslib.mjs';
+import { CallExecutionError } from './errors/CallExecutionError.mjs';
+import { FutureCancelled } from './errors/FutureCancelled.mjs';
+import { FutureError } from './errors/FutureError.mjs';
+import { StreamEnded } from './errors/StreamEnded.mjs';
+import * as R from 'ramda';
+import { Future } from './future/future.mjs';
+import { FutureResult } from './future/result.mjs';
+import { Lock } from './synchronize.mjs';
+import { ExecutorState } from './stream/state.mjs';
+import { TimeableObject } from './data-structures/object/TimeableObject.mjs';
+import { IllegalOperationError } from './errors/IllegalOperationError.mjs';
+import './data-structures/object/WatchableObject.mjs';
+import 'uuid';
+import { Queue } from './data-structures/object/Queue.mjs';
+import { AtomicValue } from './data/value.mjs';
+
+var ActionType;
+(function (ActionType) {
+    ActionType[ActionType["TRANSFORM"] = 0] = "TRANSFORM";
+    ActionType[ActionType["FILTER"] = 1] = "FILTER";
+    ActionType[ActionType["LIMIT"] = 2] = "LIMIT";
+    ActionType[ActionType["UNPACK"] = 3] = "UNPACK";
+    ActionType[ActionType["PACK"] = 4] = "PACK";
+    ActionType[ActionType["CATCH"] = 5] = "CATCH";
+})(ActionType || (ActionType = {}));
+var State;
+(function (State) {
+    State[State["MATCHED"] = 0] = "MATCHED";
+    State[State["CONTINUE"] = 1] = "CONTINUE";
+    State[State["DONE"] = 2] = "DONE";
+})(State || (State = {}));
+/**
+ * Handles a continuous supply of data that can be transformed and manipulated using a chain of actions
+ */
+class Stream {
+    constructor(executor) {
+        this.executor = executor;
+        this.controller = new AbortController();
+        this.executed = false;
+        this.done = false;
+        this.canRunExecutor = true;
+        this.actions = [];
+        this.backlog = [];
+        this.cancelHooks = new Set();
+        this.completionHooks = new Set();
+        this.completionHookInvoked = false;
+        this.runLock = new Lock();
+        this.concurrencyLimit = 0;
+    }
+    /**
+     * Used to provide setup logic that should only be invoked once, when stream
+     * is starting. This setup logic must provide the actual data required, which
+     * can come from a Stream or Future
+     * @param supplier
+     */
+    static seed(supplier) {
+        return new Future((resolve, reject, signal) => {
+            resolve(supplier());
+        }).stream;
+    }
+    /**
+     * Streams the next available result from a list of futures, until all future completes. If any future fails, then the
+     * stream will throw an error
+     * @param futures
+     */
+    static asCompleted(futures) {
+        const registerSignal = R.once((signal) => {
+            futures.forEach((future) => {
+                future.registerSignal(signal);
+            });
+        });
+        const launchFutures = R.once((futures) => {
+            const result = new Set();
+            for (let i = 0; i < futures.length; i++) {
+                const future = futures[i].clone();
+                result.add(future.thenApply((v) => [v.value, future], false));
+            }
+            return result;
+        });
+        return new Stream((signal) => __awaiter(this, void 0, void 0, function* () {
+            registerSignal(signal);
+            const promises = launchFutures(futures);
+            if (promises.size > 0) {
+                const result = yield Promise.race(promises);
+                const [value, future] = result;
+                promises.delete(future);
+                return value;
+            }
+            return new ExecutorState(true);
+        }));
+    }
+    /**
+     * Stream the next available result from the list of streams. If any stream fails, then this merged stream also fails.
+     * @param streams
+     */
+    static merge(streams) {
+        const register = R.once((signal) => {
+            signal.onabort = () => streams.forEach((stream) => stream.cancel());
+        });
+        const buildFuture = (stream, index) => stream.future
+            .thenApply((v) => [v.value, index])
+            .catch((error) => {
+            if (error instanceof StreamEnded) {
+                return [undefined, index];
+            }
+            throw error;
+        });
+        let streamCount = streams.length;
+        const futures = streams.map((stream, index) => buildFuture(stream, index));
+        return new Stream((signal) => __awaiter(this, void 0, void 0, function* () {
+            register(signal);
+            while (streamCount > 0) {
+                const [value, index] = yield Future.firstCompleted(futures);
+                if (value === undefined) {
+                    futures[index] = new Future(() => { });
+                    streamCount--;
+                }
+                else {
+                    futures[index] = buildFuture(streams[index], index);
+                    return value;
+                }
+            }
+            return new ExecutorState(true);
+        }));
+    }
+    /**
+     * Aggregates the results from multiple streams
+     * @param streams
+     */
+    static zip(streams) {
+        const register = R.once((signal) => (signal.onabort = () => streams.forEach((stream) => stream.cancel())));
+        return new Stream((signal) => __awaiter(this, void 0, void 0, function* () {
+            register(signal);
+            try {
+                return yield Future.collect(streams.map((stream) => stream.future));
+            }
+            catch (error) {
+                if (error instanceof StreamEnded) {
+                    return new ExecutorState(true);
+                }
+                throw error;
+            }
+        }));
+    }
+    /**
+     * Converts the provided value to a stream
+     * @param value
+     */
+    static of(value) {
+        if (value[Symbol.iterator]) {
+            const iterator = value[Symbol.iterator]();
+            return new Stream((signal) => {
+                if (!signal.aborted) {
+                    const { value, done } = iterator.next();
+                    return new ExecutorState(done, value);
+                }
+            });
+        }
+        else if (value instanceof Future) {
+            let completed = false;
+            return new Stream((signal) => __awaiter(this, void 0, void 0, function* () {
+                if (completed) {
+                    return new ExecutorState(true);
+                }
+                value.registerSignal(signal);
+                completed = true;
+                return new ExecutorState(false, yield value);
+            }));
+        }
+        const getIterator = value instanceof Function
+            ? R.once((v) => value(v))
+            : R.once((v) => value[Symbol.asyncIterator]());
+        return new Stream((signal) => __awaiter(this, void 0, void 0, function* () {
+            if (!signal.aborted) {
+                const iterator = getIterator(signal);
+                const { value, done } = yield iterator.next();
+                return new ExecutorState(done, value);
+            }
+        }));
+    }
+    /**
+     * Stream that never gives a result
+     */
+    static forever() {
+        return new Stream(() => { });
+    }
+    get isParallel() {
+        return this.concurrencyLimit && this.sourceStream;
+    }
+    /**
+     * Gets a future of the next value on the stream, if any.
+     */
+    get future() {
+        return Future.of((resolve, reject, signal) => {
+            if (!signal.aborted) {
+                signal.onabort = () => this.cancel();
+                this.next()
+                    .then((v) => {
+                    if (v.done && v.value === undefined) {
+                        reject(new StreamEnded());
+                    }
+                    else {
+                        resolve(v.value);
+                    }
+                })
+                    .catch(reject);
+            }
+        });
+    }
+    get readableStream() {
+        const iterator = this[Symbol.asyncIterator]();
+        return new ReadableStream({
+            pull(controller) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const { value, done } = yield iterator.next();
+                    if (done) {
+                        controller.close();
+                    }
+                    else {
+                        controller.enqueue(value);
+                    }
+                });
+            },
+        });
+    }
+    /**
+     * Cancel the stream on the given signal
+     * @param signal
+     */
+    cancelOnSignal(signal) {
+        signal.addEventListener("abort", () => this.cancel());
+        return this;
+    }
+    parallel(concurrentlyLimit = 3) {
+        if (concurrentlyLimit < 1) {
+            throw new IllegalOperationError("Cannot start parallel stream less than 2");
+        }
+        const newStream = new Stream(() => { });
+        newStream.concurrencyLimit = concurrentlyLimit;
+        newStream.sourceStream = this;
+        newStream.executed = this.executed;
+        newStream.done = this.done;
+        newStream.cancelHooks = new Set(this.cancelHooks);
+        newStream.completionHooks = new Set(this.completionHooks);
+        newStream.completionHookInvoked = this.completionHookInvoked;
+        return newStream;
+    }
+    /**
+     * Transforms each data on the stream using the callback provided
+     * @param callback
+     */
+    map(callback) {
+        this.actions.push({ type: ActionType.TRANSFORM, functor: callback });
+        return this;
+    }
+    /**
+     * Filters data on the stream using the callback provided
+     * @param callback
+     */
+    filter(callback) {
+        this.actions.push({
+            type: ActionType.FILTER,
+            functor: (v) => __awaiter(this, void 0, void 0, function* () {
+                if (v instanceof FutureResult)
+                    v = v.value;
+                let result = callback(v);
+                if (result instanceof Promise || result instanceof Future)
+                    result = yield result;
+                if (result)
+                    return v;
+                return null;
+            }),
+        });
+        return this;
+    }
+    reduce(initialData, functor, exhaustive = true) {
+        let previousData = initialData;
+        if (exhaustive) {
+            this.actions.push({
+                type: ActionType.PACK,
+                functor: (v) => {
+                    if (v === null || v === undefined) {
+                        return { done: true, value: previousData };
+                    }
+                    previousData = functor(v, previousData);
+                    return { done: false };
+                },
+            });
+        }
+        else {
+            this.actions.push({
+                type: ActionType.TRANSFORM,
+                functor: (v) => {
+                    previousData = functor(v, previousData);
+                    return previousData;
+                },
+            });
+        }
+        return this;
+    }
+    reduceWhile(predicate, initialData, functor, exhaustive = true) {
+        let previousData = initialData;
+        if (exhaustive) {
+            this.actions.push({
+                type: ActionType.PACK,
+                functor: (v) => {
+                    if (v === null || v === undefined || predicate(v)) {
+                        return { done: true, value: previousData };
+                    }
+                    previousData = functor(v, previousData);
+                    return { done: false };
+                },
+            });
+        }
+        else {
+            this.actions.push({
+                type: ActionType.LIMIT,
+                functor: (v) => {
+                    if (predicate(v)) {
+                        previousData = functor(v, previousData);
+                        return { done: false, value: previousData };
+                    }
+                    return { done: true };
+                },
+            });
+        }
+        return this;
+    }
+    /**
+     * Retrieves the first value from the stream as a new stream. Important Note: the original stream cannot be executed
+     * before head() is invoked, otherwise the stream returned by head() will throw an error, as the first value was
+     * already consumed elsewhere
+     */
+    head() {
+        return new Stream(() => __awaiter(this, void 0, void 0, function* () {
+            return new ExecutorState(true, yield this.execute());
+        }));
+    }
+    /**
+     * Returns a new stream that exhausts the original stream, yielding the last value received before the original
+     * stream ended
+     */
+    tail() {
+        let lastRecord = null;
+        return new Stream(() => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            try {
+                for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        const value = _c;
+                        lastRecord = value;
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return new ExecutorState(true, lastRecord);
+        }));
+    }
+    /**
+     * group data on the stream into separate slices
+     * E.g. Stream yielding 1,2,3,4,5,6 with chunk of 2 => [1,2], [3,4], [5,6]
+     * @param value chunk size or function that indicates when to split
+     * @param keepSplitCriteria if value provided was a function, this parameter is used to determine if the data used
+     * for the split criteria should be added to the chunk, if false then the data will be added to the next chunk
+     */
+    chunk(value, keepSplitCriteria = false) {
+        if (typeof value === "number" && value < 1)
+            throw new Error("Invalid chunk size");
+        let chunkedResults = [];
+        if (typeof value === "number") {
+            this.actions.push({
+                type: ActionType.PACK,
+                functor: (v) => {
+                    if (v === undefined || v === null) {
+                        return { done: true, value: chunkedResults.length > 0 ? chunkedResults : undefined };
+                    }
+                    chunkedResults.push(v);
+                    if (chunkedResults.length >= value) {
+                        const data = chunkedResults;
+                        chunkedResults = [];
+                        return { done: true, value: data };
+                    }
+                    return { done: false };
+                },
+            });
+        }
+        else {
+            this.actions.push({
+                type: ActionType.TRANSFORM,
+                functor: (v) => {
+                    if (value(v)) {
+                        if (keepSplitCriteria)
+                            chunkedResults.push(v);
+                        const data = chunkedResults;
+                        chunkedResults = [];
+                        return { done: true, value: data };
+                    }
+                    chunkedResults.push(v);
+                    return { done: false };
+                },
+            });
+        }
+        return this;
+    }
+    /**
+     * Clones the stream
+     * @param withSignals should the abort signals of the original stream trigger the cloned stream cancellation
+     */
+    clone(withSignals) {
+        const newStream = new Stream(this.executor);
+        newStream.concurrencyLimit = this.concurrencyLimit;
+        newStream.sourceStream = this.sourceStream;
+        newStream.actions = [...this.actions];
+        newStream.executed = this.executed;
+        newStream.done = this.done;
+        newStream.backlog = [...this.backlog];
+        newStream.cancelHooks = new Set(this.cancelHooks);
+        newStream.completionHooks = new Set(this.completionHooks);
+        newStream.completionHookInvoked = this.completionHookInvoked;
+        if (withSignals) {
+            newStream.controller = this.controller;
+        }
+        return newStream;
+    }
+    /**
+     * Register hook that is only ever called if stream was cancelled
+     * @param hook
+     */
+    onCancellation(hook) {
+        this.cancelHooks.add(hook);
+        return this;
+    }
+    removeCancelHook(hook) {
+        this.cancelHooks.delete(hook);
+        return this;
+    }
+    /**
+     * Register hook that is called once the stream completes, cancelled or fails
+     * @param hook
+     */
+    onCompletion(hook) {
+        this.completionHooks.add(hook);
+        return this;
+    }
+    removeCompletionHook(hook) {
+        this.completionHooks.delete(hook);
+        return this;
+    }
+    /**
+     * Cancels the stream
+     * @param reason
+     */
+    cancel(reason) {
+        this.controller.abort(reason);
+        this.invokeCompletionHooks();
+        this.cancelHooks.forEach((handler) => {
+            void new Promise((resolve, reject) => {
+                try {
+                    handler();
+                    resolve(null);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
+    /**
+     * Limits the number of times the stream can yield a value
+     * @param count
+     */
+    take(count) {
+        let index = 0;
+        this.actions.push({
+            type: ActionType.LIMIT,
+            functor: (value) => {
+                if (++index < count) {
+                    return { value, done: false };
+                }
+                return { done: true, value };
+            },
+        });
+        return this;
+    }
+    /**
+     * Process stream data while predicate is true
+     * @param predicate
+     */
+    takeWhile(predicate) {
+        this.actions.push({
+            type: ActionType.LIMIT,
+            functor: (value) => {
+                if (predicate(value)) {
+                    return { value, done: false };
+                }
+                return { done: true };
+            },
+        });
+        return this;
+    }
+    /**
+     * Drop stream data until predicate is no longer true
+     * @param predicate
+     */
+    skipWhile(predicate) {
+        let startFound = false;
+        this.actions.push({
+            type: ActionType.FILTER,
+            functor: (value) => {
+                if (!startFound && predicate(value)) {
+                    return null;
+                }
+                startFound = true;
+                return value;
+            },
+        });
+        return this;
+    }
+    /**
+     * Removes duplicates from the stream based on the key extractor functor provided
+     * @param uniqKeyExtractor
+     * @param expiryPeriod
+     */
+    dropRepeats(uniqKeyExtractor, expiryPeriod = undefined) {
+        const cache = new TimeableObject(undefined, expiryPeriod);
+        this.actions.push({
+            type: ActionType.FILTER,
+            functor: (v) => __awaiter(this, void 0, void 0, function* () {
+                const guid = uniqKeyExtractor(v);
+                if (!cache.has(guid)) {
+                    cache.set(guid, 1);
+                    return v;
+                }
+                return null;
+            }),
+        });
+        return this;
+    }
+    /**
+     * Allows the stream to yield only 1 value
+     */
+    once() {
+        return this.take(1);
+    }
+    /**
+     * Skips the first X records on the stream
+     * @param count
+     */
+    skip(count) {
+        let index = 1;
+        this.actions.push({
+            type: ActionType.FILTER,
+            functor: (value) => {
+                if (index && index++ <= count)
+                    return null;
+                index = 0;
+                return value;
+            },
+        });
+        return this;
+    }
+    /**
+     * Applies rate limiting to the speed at which the data is made available on the stream
+     * @param period
+     */
+    throttleBy(period) {
+        let future;
+        this.actions.push({
+            type: ActionType.TRANSFORM,
+            functor: (value) => {
+                if (!future) {
+                    future = Future.sleep(period)
+                        .thenApply(() => (future = undefined))
+                        .schedule();
+                    return value;
+                }
+                return null;
+            },
+        });
+        return this;
+    }
+    /**
+     * Flattens any nested structure from the data arriving on the stream
+     */
+    flatten() {
+        this.actions.push({
+            type: ActionType.UNPACK,
+            functor: (value) => {
+                if (value instanceof Array || Array.isArray(value) || value instanceof Set)
+                    return R.flatten(value);
+                return [value];
+            },
+        });
+        return this;
+    }
+    /**
+     * Runs the stream in the background, collecting and buffering the results for the next chain in the stream. This
+     * allows the stream to run concurrently without waiting on single emitted values sequentially
+     * @param maxSize
+     */
+    buffer(maxSize) {
+        return Stream.seed(() => {
+            const queue = new Queue(maxSize);
+            this.forEach((record) => queue.awaitEnqueue(record)).finally(() => {
+                queue
+                    .awaitEmpty()
+                    .thenApply(() => queue.close())
+                    .schedule();
+            });
+            return queue.streamEntries.catch((error) => {
+                throw error;
+            });
+        });
+    }
+    /**
+     * Process stream values in the background, thereby yielding the latest value if the collector of the stream is too
+     * slow (i.e. values that are not read by collector before new value flows in the stream, will be dropped)
+     */
+    conflate() {
+        return Stream.seed(() => {
+            const value = new AtomicValue();
+            this.forEach((record) => value.set(record))
+                .finally(() => value.destroy())
+                .schedule();
+            return value.stream;
+        });
+    }
+    /**
+     * If the stream receives an error, handle that error with the given callback. If callback doesn't throw an error,
+     * then the stream will recover and resume with the result provided by the callback
+     * @param callback
+     */
+    catch(callback) {
+        this.actions.push({
+            type: ActionType.CATCH,
+            functor: callback,
+        });
+        return this;
+    }
+    /**
+     * Consumes the entire stream and store the data in an array. Future is immediately executed
+     */
+    collect(collector) {
+        return collector(this.isParallel ? this.join() : this).schedule();
+    }
+    /**
+     * Continuously exhaust the stream until the stream ends or the limit is reached. No result will be provided at
+     * the end. Future is immediately executed
+     * @param limit
+     */
+    consume(limit = Number.POSITIVE_INFINITY) {
+        return new Future((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_2, _b, _c, _d, e_3, _e, _f;
+            var _g;
+            try {
+                if (limit !== Number.POSITIVE_INFINITY && limit !== Number.NEGATIVE_INFINITY) {
+                    if (limit === 0)
+                        return;
+                    let index = 0;
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        for (var _h = true, _j = __asyncValues(this), _k; _k = yield _j.next(), _a = _k.done, !_a;) {
+                            _c = _k.value;
+                            _h = false;
+                            try {
+                                const _ = _c;
+                                if (++index >= limit)
+                                    break;
+                            }
+                            finally {
+                                _h = true;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (!_h && !_a && (_b = _j.return)) yield _b.call(_j);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+                else {
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-empty
+                        for (var _l = true, _m = __asyncValues(this), _o; _o = yield _m.next(), _d = _o.done, !_d;) {
+                            _f = _o.value;
+                            _l = false;
+                            try {
+                                const _ = _f;
+                            }
+                            finally {
+                                _l = true;
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (!_l && !_d && (_e = _m.return)) yield _e.call(_m);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+                resolve();
+            }
+            catch (error) {
+                reject(error instanceof FutureError ? error : new FutureError((_g = error === null || error === void 0 ? void 0 : error.message) !== null && _g !== void 0 ? _g : "Unknown"));
+            }
+        })).schedule();
+    }
+    /**
+     * Iterates over the stream of values, used as a collector. Future is immediately executed
+     * @param callback
+     */
+    forEach(callback) {
+        return new Future((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield this.map((value) => callback(value))
+                    .consume()
+                    .registerSignal(signal);
+                resolve();
+            }
+            catch (error) {
+                reject(error instanceof FutureError ? error : new FutureError((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : "Unknown"));
+            }
+        })).schedule();
+    }
+    /**
+     * Runs the stream only once. After this call, the stream is closed. Future is immediately executed
+     */
+    execute() {
+        return this.runLock
+            .with(({ signal }) => __awaiter(this, void 0, void 0, function* () {
+            if (this.executed)
+                throw new CallExecutionError("Cannot rerun a one time stream");
+            while (true) {
+                const { state, value } = yield (this.sourceStream && this.concurrencyLimit
+                    ? this.forwardExecute().registerSignal(signal)
+                    : this.__execute__().registerSignal(signal));
+                if (state !== State.CONTINUE) {
+                    this.done = true;
+                    this.invokeCompletionHooks();
+                    return value;
+                }
+            }
+        }))
+            .schedule();
+    }
+    join() {
+        if (!this.concurrencyLimit || !this.sourceStream) {
+            throw new IllegalOperationError("Join can only be called on a parallel stream");
+        }
+        return Stream.of(this.internalIterator()).flatten();
+    }
+    [Symbol.asyncIterator]() {
+        return this.isParallel ? this.join() : this;
+    }
+    next(...args) {
+        if (this.concurrencyLimit || this.sourceStream) {
+            throw new IllegalOperationError("Iterator cannot be called on a parallel stream.Please join first");
+        }
+        return this.internalNext().run();
+    }
+    return(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.concurrencyLimit || this.sourceStream) {
+                throw new IllegalOperationError("Iterator cannot be called on a parallel stream.Please join first");
+            }
+            return { done: true, value: yield this.execute().run() };
+        });
+    }
+    throw(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                done: true,
+                value: undefined,
+            };
+        });
+    }
+    __execute__(preProcessor = R.identity) {
+        return Future.of((resolve, __, signal) => __awaiter(this, void 0, void 0, function* () {
+            this.executed = true;
+            let i = 0;
+            let traversableActions = this.actions;
+            let data;
+            try {
+                const { index: actionStream, data: actionData } = yield this.checkBacklog(signal);
+                if (actionStream >= 0) {
+                    i = actionStream;
+                    data = actionData;
+                }
+                else if (this.canRunExecutor) {
+                    do {
+                        data = this.executor(this.controller.signal);
+                        do {
+                            if (data instanceof ExecutorState) {
+                                this.canRunExecutor = !data.done;
+                                data = data.value;
+                                if (!this.canRunExecutor && (data === null || data === undefined)) {
+                                    [data, traversableActions] = yield this.findAndExecuteMostRecentPacker(signal);
+                                    if (data === undefined) {
+                                        return resolve({ state: State.DONE });
+                                    }
+                                }
+                            }
+                            if (data instanceof Promise)
+                                data = yield data;
+                            if (data instanceof Future)
+                                data = yield data.registerSignal(signal);
+                            if (data instanceof FutureResult)
+                                data = data.value;
+                            if (data instanceof Stream) {
+                                this.backlog.push({ actionStream: 0, records: data });
+                                return resolve({ state: State.CONTINUE });
+                            }
+                        } while (data instanceof ExecutorState);
+                    } while (data === undefined && this.canRunExecutor);
+                }
+                else {
+                    [data, traversableActions] = yield this.findAndExecuteMostRecentPacker(signal);
+                    if (data === undefined) {
+                        return resolve({ state: State.DONE });
+                    }
+                }
+            }
+            catch (e) {
+                const [value, index] = yield this.processError(e, i, traversableActions, signal);
+                i = index + 1;
+                if (value === undefined || value === null)
+                    return resolve({ state: State.CONTINUE });
+                data = value;
+            }
+            resolve(yield this.processor(i, traversableActions, data, preProcessor, signal));
+        }), this.controller.signal);
+    }
+    processor(index, traversableActions, record, preProcessor = R.identity, signal) {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            let data = record;
+            for (let i = index; i < traversableActions.length; i++) {
+                try {
+                    const { type, functor } = traversableActions[i];
+                    switch (type) {
+                        case ActionType.FILTER: {
+                            const preResult = yield this.yieldTrueResult(preProcessor(data), signal);
+                            const result = yield this.yieldTrueResult(functor(preResult instanceof Promise ? yield preResult : preResult), signal);
+                            if (result === null || result === undefined) {
+                                return resolve({ state: State.CONTINUE });
+                            }
+                            data = result;
+                            break;
+                        }
+                        case ActionType.TRANSFORM: {
+                            const preResult = yield this.yieldTrueResult(preProcessor(data), signal);
+                            const result = yield this.yieldTrueResult(functor(preResult instanceof Promise ? yield preResult : preResult), signal);
+                            if (result instanceof Stream) {
+                                this.backlog = [{ actionStream: i + 1, records: result }, ...this.backlog];
+                                return resolve({ state: State.CONTINUE });
+                            }
+                            data = result;
+                            break;
+                        }
+                        case ActionType.PACK: {
+                            const preResult = yield this.yieldTrueResult(preProcessor(data), signal);
+                            const result = (yield this.yieldTrueResult(functor(preResult instanceof Promise ? yield preResult : preResult), signal));
+                            if (!result.done) {
+                                return resolve({ state: State.CONTINUE });
+                            }
+                            data = result.value;
+                            break;
+                        }
+                        case ActionType.LIMIT: {
+                            const preResult = yield this.yieldTrueResult(preProcessor(data), signal);
+                            const result = (yield this.yieldTrueResult(functor(preResult instanceof Promise ? yield preResult : preResult), signal));
+                            if (result.done) {
+                                this.canRunExecutor = false;
+                                this.backlog = [];
+                                this.actions = traversableActions.splice(i + 1);
+                                traversableActions = this.actions;
+                                i = -1;
+                            }
+                            data = result.value;
+                            break;
+                        }
+                        case ActionType.UNPACK: {
+                            const preResult = yield this.yieldTrueResult(preProcessor(data), signal);
+                            const result = (yield this.yieldTrueResult(functor(preResult instanceof Promise ? yield preResult : preResult), signal));
+                            if (result.length === 0) {
+                                return resolve({ state: State.CONTINUE });
+                            }
+                            else if (result.length === 1) {
+                                data = result[0];
+                            }
+                            else {
+                                const value = result.shift();
+                                this.backlog = [{ actionStream: i + 1, records: result }, ...this.backlog];
+                                data = value;
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    const [value, index] = yield this.processError(error, i, traversableActions, signal);
+                    i = index;
+                    if (value !== undefined && value !== null)
+                        data = value;
+                }
+            }
+            return resolve({ state: State.MATCHED, value: data });
+        }), signal);
+    }
+    internalIterator() {
+        const iterator = {
+            next: () => this.internalNext().run(),
+            return: this.return.bind(this),
+            throw: this.throw,
+            [Symbol.asyncIterator]() {
+                return iterator;
+            },
+        };
+        return iterator;
+    }
+    checkBacklog(signal) {
+        return Future.of((resolve, __, signal) => __awaiter(this, void 0, void 0, function* () {
+            if (this.backlog.length === 0)
+                return resolve({ index: -1 });
+            const { actionStream, records } = this.backlog[0];
+            const index = actionStream;
+            if (records instanceof Stream) {
+                const hook = () => records.cancel();
+                this.onCancellation(hook);
+                try {
+                    const { value: data, done } = yield records[Symbol.asyncIterator]().next();
+                    if (done) {
+                        this.backlog.shift();
+                        return resolve(yield this.checkBacklog(signal));
+                    }
+                    return resolve({ index, data });
+                }
+                finally {
+                    this.removeCancelHook(hook);
+                }
+            }
+            else {
+                const data = records.shift();
+                if (records.length === 0) {
+                    this.backlog.shift();
+                }
+                return resolve({ index, data });
+            }
+        }), signal);
+    }
+    internalNext() {
+        return this.runLock.with(({ signal }) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                while (!this.done) {
+                    const { state, value } = yield (this.sourceStream && this.concurrencyLimit
+                        ? this.forwardExecute()
+                        : this.__execute__());
+                    if (state === State.MATCHED && value !== undefined)
+                        return { done: false, value };
+                    if (state === State.DONE) {
+                        this.done = true;
+                        if (value !== undefined)
+                            return { done: false, value };
+                    }
+                    if (this.controller.signal.aborted) {
+                        this.done = true;
+                    }
+                }
+                this.invokeCompletionHooks();
+                return { done: true, value: undefined };
+            }
+            catch (error) {
+                this.invokeCompletionHooks();
+                if (error instanceof StreamEnded || error instanceof FutureCancelled)
+                    return { done: true, value: null };
+                throw error;
+            }
+        }));
+    }
+    invokeCompletionHooks() {
+        if (this.completionHookInvoked) {
+            return;
+        }
+        this.completionHookInvoked = true;
+        this.completionHooks.forEach((handler) => {
+            void new Promise((resolve, reject) => {
+                try {
+                    handler();
+                    resolve(null);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        this.backlog.forEach(({ records }) => {
+            if (records instanceof Stream) {
+                records.cancel();
+            }
+        });
+    }
+    processError(error, i, actions, signal) {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            let errorMessage;
+            if (actions.length === 0)
+                throw error;
+            else if (!(error instanceof Error))
+                errorMessage = new Error(error);
+            else
+                errorMessage = error;
+            const catchAction = actions.splice(i).find((v, index) => {
+                if (v.type === ActionType.CATCH) {
+                    i = index;
+                    return true;
+                }
+                return false;
+            });
+            if (!catchAction)
+                throw error;
+            try {
+                const value = catchAction.functor(errorMessage);
+                return resolve([yield this.yieldTrueResult(value, signal), i]);
+            }
+            catch (e) {
+                return resolve(yield this.processError(e, i, actions, signal));
+            }
+        }), signal);
+    }
+    findAndExecuteMostRecentPacker(signal) {
+        return Future.of((resolve, __, signal) => __awaiter(this, void 0, void 0, function* () {
+            const index = this.actions.findIndex((action) => action.type === ActionType.PACK);
+            if (index >= 0) {
+                const functor = this.actions[index].functor;
+                const result = (yield this.yieldTrueResult(functor(undefined), signal));
+                if (result.done) {
+                    return resolve([result.value, this.actions.slice(index + 1)]);
+                }
+            }
+            return resolve([undefined, []]);
+        }), signal);
+    }
+    yieldTrueResult(value, signal) {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            if (value instanceof Future)
+                value = yield value.registerSignal(signal);
+            if (value instanceof FutureResult)
+                value = value.value;
+            if (value instanceof Promise)
+                value = yield value;
+            resolve(value);
+        }), signal);
+    }
+    forwardExecute(preProcessor = R.identity) {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_4, _b, _c;
+            let pending = [];
+            try {
+                for (var _d = true, _e = __asyncValues(this.sourceStream.internalIterator()), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        const data = _c;
+                        pending.push(this.processor(0, this.actions, data, preProcessor, signal));
+                        if (pending.length === this.concurrencyLimit) {
+                            const result = yield this.collectResult(pending, signal);
+                            if (result.state === State.CONTINUE) {
+                                pending = [];
+                            }
+                            else {
+                                return resolve(result);
+                            }
+                        }
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            const { state, value } = yield this.collectResult(pending, signal);
+            if (state === State.CONTINUE) {
+                return resolve({ state: State.DONE });
+            }
+            return resolve({ state: State.DONE, value });
+        }));
+    }
+    collectResult(pending, signal) {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            let doneFound = false;
+            const results = (yield Future.collect(pending).registerSignal(signal)).filter((v) => {
+                if (v.state === State.DONE) {
+                    doneFound = true;
+                    return true;
+                }
+                else if (v.state === State.MATCHED) {
+                    return true;
+                }
+                return false;
+            });
+            if (doneFound) {
+                return resolve({ state: State.DONE, value: results.map((v) => v.value) });
+            }
+            else if (results.length) {
+                return resolve({ state: State.MATCHED, value: results.map((v) => v.value) });
+            }
+            return resolve({ state: State.CONTINUE });
+        }), signal);
+    }
+}
+
+export { State, Stream };