@takeshape/streams 11.143.2 → 11.154.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/streams",
-  "version": "11.143.2",
+  "version": "11.154.1",
   "description": "Stream helpers",
   "homepage": "https://www.takeshape.io",
   "repository": {

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from './merge.ts';
-export * from './streams.ts';

package/dist/index.js

@@ -1,2 +0,0 @@
-export * from "./merge.js";
-export * from "./streams.js";

package/dist/merge.d.ts

@@ -1,8 +0,0 @@
-import { PassThrough as PassThroughStream, type Readable } from 'node:stream';
-export declare function mergeStreams(streams: Readable[]): MergedStream;
-declare class MergedStream extends PassThroughStream {
-    #private;
-    add(stream: Readable): void;
-    remove(stream: Readable): Promise<boolean>;
-}
-export {};

package/dist/merge.js

@@ -1,246 +0,0 @@
-/* istanbul ignore file -- @preserve */
-/**
- * Borrowed code, due to ESM-only issues
- *
- * @link https://github.com/sindresorhus/merge-streams/blob/main/index.js
- */
-import { on, once } from 'node:events';
-import { getDefaultHighWaterMark, PassThrough as PassThroughStream } from 'node:stream';
-import { finished } from 'node:stream/promises';
-export function mergeStreams(streams) {
-    if (!Array.isArray(streams)) {
-        throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
-    }
-    for (const stream of streams) {
-        validateStream(stream);
-    }
-    const objectMode = streams.some(({ readableObjectMode }) => readableObjectMode);
-    const highWaterMark = getHighWaterMark(streams, objectMode);
-    const passThroughStream = new MergedStream({
-        objectMode,
-        writableHighWaterMark: highWaterMark,
-        readableHighWaterMark: highWaterMark
-    });
-    for (const stream of streams) {
-        passThroughStream.add(stream);
-    }
-    return passThroughStream;
-}
-const getHighWaterMark = (streams, objectMode) => {
-    if (streams.length === 0) {
-        return getDefaultHighWaterMark(objectMode);
-    }
-    const highWaterMarks = streams
-        .filter(({ readableObjectMode }) => readableObjectMode === objectMode)
-        .map(({ readableHighWaterMark }) => readableHighWaterMark);
-    return Math.max(...highWaterMarks);
-};
-class MergedStream extends PassThroughStream {
-    #streams = new Set([]);
-    #ended = new Set([]);
-    #aborted = new Set([]);
-    #onFinished;
-    #unpipeEvent = Symbol('unpipe');
-    #streamPromises = new WeakMap();
-    add(stream) {
-        validateStream(stream);
-        if (this.#streams.has(stream)) {
-            return;
-        }
-        this.#streams.add(stream);
-        this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
-        const streamPromise = endWhenStreamsDone({
-            passThroughStream: this,
-            stream,
-            streams: this.#streams,
-            ended: this.#ended,
-            aborted: this.#aborted,
-            onFinished: this.#onFinished,
-            unpipeEvent: this.#unpipeEvent
-        });
-        this.#streamPromises.set(stream, streamPromise);
-        stream.pipe(this, { end: false });
-    }
-    async remove(stream) {
-        validateStream(stream);
-        if (!this.#streams.has(stream)) {
-            return false;
-        }
-        const streamPromise = this.#streamPromises.get(stream);
-        if (streamPromise === undefined) {
-            return false;
-        }
-        this.#streamPromises.delete(stream);
-        stream.unpipe(this);
-        await streamPromise;
-        return true;
-    }
-}
-const onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
-    updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
-    const controller = new AbortController();
-    try {
-        await Promise.race([
-            onMergedStreamEnd(passThroughStream, controller),
-            onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller)
-        ]);
-    }
-    finally {
-        controller.abort();
-        updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
-    }
-};
-const onMergedStreamEnd = async (passThroughStream, { signal }) => {
-    try {
-        await finished(passThroughStream, {
-            signal,
-            cleanup: true
-        });
-    }
-    catch (error) {
-        errorOrAbortStream(passThroughStream, error);
-        throw error;
-    }
-};
-const onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
-    for await (const [unpipedStream] of on(passThroughStream, 'unpipe', {
-        signal
-    })) {
-        if (streams.has(unpipedStream)) {
-            unpipedStream.emit(unpipeEvent);
-        }
-    }
-};
-const validateStream = (stream) => {
-    if (typeof stream?.pipe !== 'function') {
-        throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
-    }
-};
-const endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, aborted, onFinished, unpipeEvent }) => {
-    updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
-    const controller = new AbortController();
-    try {
-        await Promise.race([
-            afterMergedStreamFinished(onFinished, stream, controller),
-            onInputStreamEnd({
-                passThroughStream,
-                stream,
-                streams,
-                ended,
-                aborted,
-                controller
-            }),
-            onInputStreamUnpipe({
-                stream,
-                streams,
-                ended,
-                aborted,
-                unpipeEvent,
-                controller
-            })
-        ]);
-    }
-    finally {
-        controller.abort();
-        updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
-    }
-    if (streams.size > 0 && streams.size === ended.size + aborted.size) {
-        if (ended.size === 0 && aborted.size > 0) {
-            abortStream(passThroughStream);
-        }
-        else {
-            endStream(passThroughStream);
-        }
-    }
-};
-const afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
-    try {
-        await onFinished;
-        if (!signal.aborted) {
-            abortStream(stream);
-        }
-    }
-    catch (error) {
-        if (!signal.aborted) {
-            errorOrAbortStream(stream, error);
-        }
-    }
-};
-const onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, aborted, controller: { signal } }) => {
-    try {
-        await finished(stream, {
-            signal,
-            cleanup: true,
-            readable: true,
-            writable: false
-        });
-        if (streams.has(stream)) {
-            ended.add(stream);
-        }
-    }
-    catch (error) {
-        if (signal.aborted || !streams.has(stream)) {
-            return;
-        }
-        if (isAbortError(error)) {
-            aborted.add(stream);
-        }
-        else {
-            errorStream(passThroughStream, error);
-        }
-    }
-};
-const onInputStreamUnpipe = async ({ stream, streams, ended, aborted, unpipeEvent, controller: { signal } }) => {
-    await once(stream, unpipeEvent, { signal });
-    if (!stream.readable) {
-        return once(signal, 'abort', { signal });
-    }
-    streams.delete(stream);
-    ended.delete(stream);
-    aborted.delete(stream);
-    return;
-};
-const endStream = (stream) => {
-    if (stream.writable) {
-        stream.end();
-    }
-};
-const errorOrAbortStream = (stream, error) => {
-    if (isAbortError(error)) {
-        abortStream(stream);
-    }
-    else {
-        errorStream(stream, error);
-    }
-};
-// This is the error thrown by `finished()` on `stream.destroy()`
-const isAbortError = (error) => error?.code === 'ERR_STREAM_PREMATURE_CLOSE';
-const abortStream = (stream) => {
-    if (stream.readable || stream.writable) {
-        stream.destroy();
-    }
-};
-// `stream.destroy(error)` crashes the process with `uncaughtException` if no `error` event listener exists on `stream`.
-// We take care of error handling on user behalf, so we do not want this to happen.
-const errorStream = (stream, error) => {
-    if (!stream.destroyed) {
-        stream.once('error', noop);
-        stream.destroy(error);
-    }
-};
-const noop = () => {
-    // empty
-};
-const updateMaxListeners = (passThroughStream, increment) => {
-    const maxListeners = passThroughStream.getMaxListeners();
-    if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
-        passThroughStream.setMaxListeners(maxListeners + increment);
-    }
-};
-// Number of times `passThroughStream.on()` is called regardless of streams:
-//  - once due to `finished(passThroughStream)`
-//  - once due to `on(passThroughStream)`
-const PASSTHROUGH_LISTENERS_COUNT = 2;
-// Number of times `passThroughStream.on()` is called per stream:
-//  - once due to `stream.pipe(passThroughStream)`
-const PASSTHROUGH_LISTENERS_PER_STREAM = 1;

package/dist/streams.d.ts

@@ -1,29 +0,0 @@
-import { Readable, type ReadableOptions, Transform, Writable, type WritableOptions } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-declare module 'node:stream' {
-    /**
-     * Experimental!
-     *
-     * Provisional typing for experimental feature: https://nodejs.org/dist/latest-v20.x/docs/api/stream.html#streamcomposestreams
-     *
-     * Combines two or more streams into a Duplex stream that writes to the first stream and reads from the last. Each provided stream is piped into the next, using stream.pipeline. If any of the streams error then all are destroyed, including the outer Duplex stream.
-     *
-     * Because stream.compose returns a new stream that in turn can (and should) be piped into other streams, it enables composition. In contrast, when passing streams to stream.pipeline, typically the first stream is a readable stream and the last a writable stream, forming a closed circuit.
-     *
-     * If passed a Function it must be a factory method taking a source Iterable.
-     */
-    const compose: (stream: NodeJS.ReadableStream, ...streams: Array<NodeJS.WritableStream | NodeJS.ReadWriteStream | Iterable<unknown>>) => NodeJS.ReadWriteStream;
-}
-export { compose } from 'node:stream';
-export declare const pump: typeof pipeline;
-export declare function streamToPromise(stream: NodeJS.ReadableStream | NodeJS.WritableStream): Promise<void>;
-export declare function createTransform(transform: (data: any) => any): Transform;
-export declare function createAsyncTransform(transform: (data: any) => Promise<any>): Transform;
-export declare function createFilter(predicate: (data: any) => boolean): Transform;
-export declare function createAccumulator(accumulator: (data: any) => void): Transform;
-export declare function createAsyncWritable(write: (data: any) => Promise<void>, concurrency?: number): Writable;
-export declare function tee(...args: NodeJS.WritableStream[] | [NodeJS.WritableStream[]]): Writable;
-export declare function readableFromArray(array: any[], options?: Partial<ReadableOptions>): Readable;
-export declare function collectStreamIntoArray(array?: any[], options?: Partial<WritableOptions>): Writable;
-export declare function readStreamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer<ArrayBuffer>>;
-export declare function batch(size: number): Transform;

package/dist/streams.js

@@ -1,147 +0,0 @@
-import { PassThrough, Readable, Transform, Writable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { promisify } from 'node:util';
-import isStream from 'is-stream';
-import PQueue from 'p-queue';
-export { compose } from 'node:stream';
-export const pump = pipeline;
-export async function streamToPromise(stream) {
-    return new Promise((resolve, reject) => {
-        const doneEvent = isStream.writable(stream) ? 'finish' : 'end';
-        stream.on('error', reject).on(doneEvent, resolve);
-    });
-}
-export function createTransform(transform) {
-    return new Transform({
-        objectMode: true,
-        transform(chunk, _, callback) {
-            try {
-                this.push(transform(chunk));
-                callback();
-            }
-            catch (e) {
-                callback(e);
-            }
-        }
-    });
-}
-export function createAsyncTransform(transform) {
-    return new Transform({
-        objectMode: true,
-        transform(chunk, _, callback) {
-            try {
-                transform(chunk).then((result) => {
-                    this.push(result);
-                    callback();
-                }, callback);
-            }
-            catch (e) {
-                callback(e);
-            }
-        }
-    });
-}
-export function createFilter(predicate) {
-    return new Transform({
-        objectMode: true,
-        transform(chunk, _, callback) {
-            try {
-                if (predicate(chunk)) {
-                    this.push(chunk);
-                }
-                callback();
-            }
-            catch (e) {
-                callback(e);
-            }
-        }
-    });
-}
-export function createAccumulator(accumulator) {
-    return new Transform({
-        objectMode: true,
-        transform(chunk, _, callback) {
-            accumulator(chunk);
-            callback(null, chunk);
-        }
-    });
-}
-export function createAsyncWritable(write, concurrency = 16) {
-    const queue = new PQueue({ concurrency });
-    return new Writable({
-        objectMode: true,
-        write(chunk, _, callback) {
-            queue.add(async () => write(chunk)).catch((error) => this.emit('error', error));
-            callback();
-        },
-        final(callback) {
-            void queue.onIdle().then(() => {
-                callback();
-            });
-        }
-    });
-}
-export function tee(...args) {
-    const first = args[0];
-    const streams = Array.isArray(first) ? first : args;
-    const donePromises = streams.map(streamToPromise);
-    return new Writable({
-        objectMode: true,
-        write(chunk, _, callback) {
-            void Promise.all(streams.map((stream) => stream.write(chunk) || promisify((cb) => stream.once('drain', cb)) // If .write() => false buffer is full, start promise to wait for drain event
-            )).then(() => {
-                callback();
-            });
-        },
-        final(callback) {
-            for (const stream of streams) {
-                stream.end();
-            }
-            void Promise.all(donePromises).then(() => {
-                callback();
-            });
-        }
-    });
-}
-export function readableFromArray(array, options) {
-    return Readable.from(array, options);
-}
-export function collectStreamIntoArray(array = [], options = {}) {
-    return new Writable({
-        objectMode: true,
-        writev(chunks, callback) {
-            for (const { chunk } of chunks) {
-                array.push(chunk);
-            }
-            callback(null);
-        },
-        ...options
-    });
-}
-export async function readStreamToBuffer(stream) {
-    const chunks = [];
-    const writeStream = new PassThrough();
-    writeStream.on('data', (chunk) => chunks.push(chunk));
-    await pump(stream, writeStream);
-    return Buffer.concat(chunks);
-}
-export function batch(size) {
-    let buffer = [];
-    return new Transform({
-        objectMode: true,
-        transform(obj, _, next) {
-            buffer.push(obj);
-            if (buffer.length === size) {
-                this.push(buffer);
-                buffer = [];
-            }
-            next();
-        },
-        flush(done) {
-            if (buffer.length > 0) {
-                this.push(buffer);
-            }
-            done();
-        }
-    });
-}