@anabranch/fs 0.1.0

package/esm/anabranch/streams/stream.js

@@ -0,0 +1,625 @@
+import { AggregateError } from "./util.js";
+const isPromise = (value) => value != null && typeof value.then === "function";
+const isAsyncIterable = (value) => {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    return Symbol.asyncIterator in Object(value);
+};
+const isIterable = (value) => {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    return Symbol.iterator in Object(value);
+};
+const toAsyncIterable = (iterable) => {
+    if (isAsyncIterable(iterable)) {
+        return iterable;
+    }
+    if (isIterable(iterable)) {
+        return (async function* () {
+            yield* iterable;
+        })();
+    }
+    throw new TypeError("flatMap function must return an iterable");
+};
+export class _StreamImpl {
+    constructor(source, concurrency = Infinity, bufferSize = Infinity) {
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: source
+        });
+        Object.defineProperty(this, "concurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: concurrency
+        });
+        Object.defineProperty(this, "bufferSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: bufferSize
+        });
+    }
+    async toArray() {
+        const results = [];
+        for await (const result of this.source()) {
+            results.push(result);
+        }
+        return results;
+    }
+    async collect() {
+        const successes = [];
+        const errors = [];
+        for await (const result of this.source()) {
+            if (result.type === "success") {
+                successes.push(result.value);
+            }
+            else {
+                errors.push(result.error);
+            }
+        }
+        if (errors.length) {
+            throw new AggregateError(errors);
+        }
+        return successes;
+    }
+    successes() {
+        const source = this.source;
+        return {
+            async *[Symbol.asyncIterator]() {
+                for await (const result of source()) {
+                    if (result.type === "success") {
+                        yield result.value;
+                    }
+                }
+            },
+        };
+    }
+    errors() {
+        const source = this.source;
+        return {
+            async *[Symbol.asyncIterator]() {
+                for await (const result of source()) {
+                    if (result.type === "error") {
+                        yield result.error;
+                    }
+                }
+            },
+        };
+    }
+    [Symbol.asyncIterator]() {
+        return this.source()[Symbol.asyncIterator]();
+    }
+    transform(handler) {
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            for await (const result of source()) {
+                const outputs = await handler(result);
+                for (const output of outputs) {
+                    yield output;
+                }
+            }
+        }, concurrency, bufferSize);
+    }
+    concurrentMap(fn, concurrency, bufferSize) {
+        return this.concurrentTransform(async (result) => {
+            if (result.type !== "success") {
+                return [result];
+            }
+            try {
+                const value = await fn(result.value);
+                return [{ type: "success", value }];
+            }
+            catch (error) {
+                return [{ type: "error", error: error }];
+            }
+        }, concurrency, bufferSize);
+    }
+    concurrentTransform(handler, concurrency, bufferSize) {
+        const source = this.source;
+        const maxConcurrency = Number.isFinite(concurrency)
+            ? Math.max(1, concurrency)
+            : Infinity;
+        const maxBufferSize = Number.isFinite(bufferSize)
+            ? Math.max(1, bufferSize)
+            : Infinity;
+        return (async function* () {
+            const queue = [];
+            let head = 0;
+            let inFlight = 0;
+            let done = false;
+            const waiters = [];
+            const wake = () => {
+                while (waiters.length > 0) {
+                    const resolve = waiters.shift();
+                    if (resolve)
+                        resolve();
+                }
+            };
+            const sleep = () => new Promise((resolve) => {
+                waiters.push(resolve);
+            });
+            const push = (result) => {
+                queue.push(result);
+                wake();
+            };
+            const size = () => queue.length - head;
+            (async () => {
+                try {
+                    for await (const result of source()) {
+                        while (inFlight >= maxConcurrency || size() >= maxBufferSize) {
+                            await sleep();
+                        }
+                        inFlight += 1;
+                        Promise.resolve()
+                            .then(async () => {
+                            const outputs = await handler(result);
+                            for (const output of outputs) {
+                                push(output);
+                            }
+                        })
+                            .finally(() => {
+                            inFlight -= 1;
+                            wake();
+                        });
+                    }
+                }
+                catch (error) {
+                    push({ type: "error", error: error });
+                }
+                done = true;
+                wake();
+            })();
+            while (true) {
+                while (size() === 0 && (!done || inFlight > 0)) {
+                    await sleep();
+                }
+                if (size() === 0) {
+                    break;
+                }
+                const next = queue[head];
+                queue[head] = undefined;
+                head += 1;
+                if (head > 256 && head * 2 >= queue.length) {
+                    queue.splice(0, head);
+                    head = 0;
+                }
+                if (next) {
+                    yield next;
+                    wake();
+                }
+            }
+        })();
+    }
+    sequentialMap(fn) {
+        const source = this.source;
+        return (async function* () {
+            for await (const result of source()) {
+                if (result.type === "success") {
+                    try {
+                        const mappedValue = fn(result.value);
+                        if (isPromise(mappedValue)) {
+                            yield {
+                                type: "success",
+                                value: await mappedValue,
+                            };
+                        }
+                        else {
+                            yield {
+                                type: "success",
+                                value: mappedValue,
+                            };
+                        }
+                    }
+                    catch (error) {
+                        yield { type: "error", error: error };
+                    }
+                }
+                else {
+                    yield result;
+                }
+            }
+        })();
+    }
+    concurrentTryMap(fn, errFn, concurrency, bufferSize) {
+        return this.concurrentTransform(async (result) => {
+            if (result.type !== "success") {
+                return [result];
+            }
+            try {
+                const value = await fn(result.value);
+                return [{ type: "success", value }];
+            }
+            catch (error) {
+                const mappedError = await errFn(error, result.value);
+                return [{ type: "error", error: mappedError }];
+            }
+        }, concurrency, bufferSize);
+    }
+    concurrentFlatMap(fn, concurrency, bufferSize) {
+        return this.concurrentTransform(async (result) => {
+            if (result.type !== "success") {
+                return [result];
+            }
+            try {
+                const mapped = await fn(result.value);
+                const outputs = [];
+                for await (const value of toAsyncIterable(mapped)) {
+                    outputs.push({ type: "success", value });
+                }
+                return outputs;
+            }
+            catch (error) {
+                return [{ type: "error", error: error }];
+            }
+        }, concurrency, bufferSize);
+    }
+    map(fn) {
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        if (Number.isFinite(concurrency) && concurrency > 1) {
+            return new _StreamImpl(() => this.concurrentMap(fn, concurrency, bufferSize), concurrency, bufferSize);
+        }
+        return new _StreamImpl(() => this.sequentialMap(fn), concurrency, bufferSize);
+    }
+    tryMap(fn, errFn) {
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        if (Number.isFinite(concurrency) && concurrency > 1) {
+            return new _StreamImpl(() => this.concurrentTryMap(fn, errFn, concurrency, bufferSize), concurrency, bufferSize);
+        }
+        return this.transform(async (result) => {
+            if (result.type === "success") {
+                try {
+                    const value = await fn(result.value);
+                    return [{ type: "success", value }];
+                }
+                catch (error) {
+                    const mappedError = await errFn(error, result.value);
+                    return [{ type: "error", error: mappedError }];
+                }
+            }
+            return [result];
+        });
+    }
+    flatMap(fn) {
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        if (Number.isFinite(concurrency) && concurrency > 1) {
+            return new _StreamImpl(() => this.concurrentFlatMap(fn, concurrency, bufferSize), concurrency, bufferSize);
+        }
+        return this.transform(async (result) => {
+            if (result.type !== "success") {
+                return [result];
+            }
+            try {
+                const mapped = await fn(result.value);
+                const outputs = [];
+                for await (const value of toAsyncIterable(mapped)) {
+                    outputs.push({ type: "success", value });
+                }
+                return outputs;
+            }
+            catch (error) {
+                return [{ type: "error", error: error }];
+            }
+        });
+    }
+    filter(fn) {
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            for await (const result of source()) {
+                if (result.type === "success") {
+                    try {
+                        const shouldInclude = fn(result.value);
+                        if (isPromise(shouldInclude)) {
+                            if (await shouldInclude) {
+                                yield result;
+                            }
+                        }
+                        else if (shouldInclude) {
+                            yield result;
+                        }
+                    }
+                    catch (error) {
+                        yield { type: "error", error: error };
+                    }
+                }
+                else {
+                    yield result;
+                }
+            }
+        }, concurrency, bufferSize);
+    }
+    tap(fn) {
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            for await (const result of source()) {
+                if (result.type === "success") {
+                    try {
+                        const ret = fn(result.value);
+                        if (isPromise(ret))
+                            await ret;
+                        yield result;
+                    }
+                    catch (error) {
+                        yield { type: "error", error: error };
+                    }
+                }
+                else {
+                    yield result;
+                }
+            }
+        }, concurrency, bufferSize);
+    }
+    tapErr(fn) {
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            for await (const result of source()) {
+                if (result.type === "error") {
+                    try {
+                        const ret = fn(result.error);
+                        if (isPromise(ret))
+                            await ret;
+                        yield result;
+                    }
+                    catch (error) {
+                        yield { type: "error", error: error };
+                    }
+                }
+                else {
+                    yield result;
+                }
+            }
+        }, concurrency, bufferSize);
+    }
+    take(n) {
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            const gen = source();
+            try {
+                let count = 0;
+                for await (const result of gen) {
+                    if (result.type === "success") {
+                        if (count >= n)
+                            break;
+                        count += 1;
+                    }
+                    yield result;
+                }
+            }
+            finally {
+                await gen.return(undefined);
+            }
+        }, concurrency, bufferSize);
+    }
+    takeWhile(fn) {
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            const gen = source();
+            try {
+                for await (const result of gen) {
+                    if (result.type === "success") {
+                        try {
+                            const shouldContinue = fn(result.value);
+                            if (isPromise(shouldContinue)
+                                ? !(await shouldContinue)
+                                : !shouldContinue) {
+                                break;
+                            }
+                            yield result;
+                        }
+                        catch (error) {
+                            yield { type: "error", error: error };
+                            break;
+                        }
+                    }
+                    else {
+                        yield result;
+                    }
+                }
+            }
+            finally {
+                await gen.return(undefined);
+            }
+        }, concurrency, bufferSize);
+    }
+    async partition() {
+        const successes = [];
+        const errors = [];
+        for await (const result of this.source()) {
+            if (result.type === "success") {
+                successes.push(result.value);
+            }
+            else {
+                errors.push(result.error);
+            }
+        }
+        return { successes, errors };
+    }
+    async fold(fn, initialValue) {
+        let accumulator = initialValue;
+        const errors = [];
+        for await (const result of this.source()) {
+            if (result.type === "success") {
+                accumulator = await fn(accumulator, result.value);
+            }
+            else {
+                errors.push(result.error);
+            }
+        }
+        if (errors.length) {
+            throw new AggregateError(errors);
+        }
+        return accumulator;
+    }
+    scan(fn, initialValue) {
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            let accumulator = initialValue;
+            for await (const result of source()) {
+                if (result.type === "success") {
+                    try {
+                        accumulator = await fn(accumulator, result.value);
+                        yield { type: "success", value: accumulator };
+                    }
+                    catch (error) {
+                        yield { type: "error", error: error };
+                    }
+                }
+                else {
+                    yield result;
+                }
+            }
+        }, concurrency, bufferSize);
+    }
+    chunks(size) {
+        if (size <= 0) {
+            throw new Error("chunks size must be positive");
+        }
+        const source = this.source;
+        const concurrency = this.concurrency;
+        const bufferSize = this.bufferSize;
+        return new _StreamImpl(async function* () {
+            let chunk = [];
+            for await (const result of source()) {
+                if (result.type === "success") {
+                    chunk.push(result.value);
+                    if (chunk.length === size) {
+                        yield { type: "success", value: chunk };
+                        chunk = [];
+                    }
+                }
+                else {
+                    if (chunk.length > 0) {
+                        yield { type: "success", value: chunk };
+                        chunk = [];
+                    }
+                    yield result;
+                }
+            }
+            if (chunk.length > 0) {
+                yield { type: "success", value: chunk };
+            }
+        }, concurrency, bufferSize);
+    }
+    mapErr(fn) {
+        return this.transform(async (result) => {
+            if (result.type === "error") {
+                try {
+                    const mappedError = await fn(result.error);
+                    return [
+                        { type: "error", error: mappedError },
+                    ];
+                }
+                catch (error) {
+                    return [
+                        { type: "error", error: error },
+                    ];
+                }
+            }
+            return [result];
+        });
+    }
+    filterErr(fn) {
+        return this.transform(async (result) => {
+            if (result.type === "error") {
+                try {
+                    const shouldInclude = await fn(result.error);
+                    if (shouldInclude) {
+                        return [result];
+                    }
+                    return [];
+                }
+                catch (error) {
+                    return [{ type: "error", error: error }];
+                }
+            }
+            return [result];
+        });
+    }
+    async foldErr(fn, initialValue) {
+        let accumulator = initialValue;
+        for await (const result of this.source()) {
+            if (result.type === "error") {
+                accumulator = await fn(accumulator, result.error);
+            }
+        }
+        return accumulator;
+    }
+    recoverWhen(guard, fn) {
+        return this.transform(async (result) => {
+            if (result.type === "error" && guard(result.error)) {
+                try {
+                    const recoveredValue = await fn(result.error);
+                    return [
+                        {
+                            type: "success",
+                            value: recoveredValue,
+                        },
+                    ];
+                }
+                catch (error) {
+                    return [
+                        {
+                            type: "error",
+                            error: error,
+                        },
+                    ];
+                }
+            }
+            return [result];
+        });
+    }
+    recover(fn) {
+        return this.transform(async (result) => {
+            if (result.type === "error") {
+                try {
+                    const recoveredValue = await fn(result.error);
+                    return [
+                        {
+                            type: "success",
+                            value: recoveredValue,
+                        },
+                    ];
+                }
+                catch (error) {
+                    return [
+                        { type: "error", error: error },
+                    ];
+                }
+            }
+            return [result];
+        });
+    }
+    throwOn(guard) {
+        const source = this.source;
+        return new _StreamImpl(async function* () {
+            for await (const result of source()) {
+                if (result.type === "error" && guard(result.error)) {
+                    // throwOn intentionally terminates iteration instead of collecting.
+                    throw result.error;
+                }
+                yield result;
+            }
+        }, this.concurrency, this.bufferSize);
+    }
+}