@takeshape/streams 11.51.6 → 11.52.0

package/README.md

@@ -1,5 +1,3 @@
 # Streams
 
-## Summary
-
-A set of utility functions for working with Node.js streams v3
+A set of utility functions for working with Node.js streams.

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-export * from './streams';
-export * from './merge';
-//# sourceMappingURL=index.d.ts.map
+export * from './streams.js';
+export * from './merge.js';

package/dist/index.js

@@ -1,27 +1,2 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _streams = require("./streams");
-Object.keys(_streams).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _streams[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _streams[key];
-    }
-  });
-});
-var _merge = require("./merge");
-Object.keys(_merge).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _merge[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _merge[key];
-    }
-  });
-});
+export * from './streams.js';
+export * from './merge.js';

package/dist/merge.d.ts

@@ -6,4 +6,3 @@ declare class MergedStream extends PassThroughStream {
     remove(stream: Readable): Promise<boolean>;
 }
 export {};
-//# sourceMappingURL=merge.d.ts.map

package/dist/merge.js

@@ -1,283 +1,246 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.mergeStreams = mergeStreams;
-var _nodeEvents = require("node:events");
-var _nodeStream = require("node:stream");
-var _promises = require("node:stream/promises");
 /* istanbul ignore file */
 /**
  * Borrowed code, due to ESM-only issues
  *
  * @link https://github.com/sindresorhus/merge-streams/blob/main/index.js
  */
-
-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;
+import { on, once } from 'node:events';
+import { PassThrough as PassThroughStream, getDefaultHighWaterMark } 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 (0, _nodeStream.getDefaultHighWaterMark)(objectMode);
-  }
-  const highWaterMarks = streams.filter(({
-    readableObjectMode
-  }) => readableObjectMode === objectMode).map(({
-    readableHighWaterMark
-  }) => readableHighWaterMark);
-  return Math.max(...highWaterMarks);
-};
-class MergedStream extends _nodeStream.PassThrough {
-  #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;
+    if (streams.length === 0) {
+        return getDefaultHighWaterMark(objectMode);
     }
-    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 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 });
     }
-    const streamPromise = this.#streamPromises.get(stream);
-    if (streamPromise === undefined) {
-      return 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;
     }
-    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 (0, _promises.finished)(passThroughStream, {
-      signal,
-      cleanup: true
-    });
-  } catch (error) {
-    errorOrAbortStream(passThroughStream, error);
-    throw error;
-  }
+    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 onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, {
-  signal
-}) => {
-  for await (const [unpipedStream] of (0, _nodeEvents.on)(passThroughStream, 'unpipe', {
-    signal
-  })) {
-    if (streams.has(unpipedStream)) {
-      unpipedStream.emit(unpipeEvent);
+const onMergedStreamEnd = async (passThroughStream, { signal }) => {
+    try {
+        await finished(passThroughStream, {
+            signal,
+            cleanup: true
+        });
+    }
+    catch (error) {
+        errorOrAbortStream(passThroughStream, error);
+        throw error;
     }
-  }
 };
-const validateStream = stream => {
-  if (typeof stream?.pipe !== 'function') {
-    throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
-  }
+const onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
+    for await (const [unpipedStream] of on(passThroughStream, 'unpipe', {
+        signal
+    })) {
+        if (streams.has(unpipedStream)) {
+            unpipedStream.emit(unpipeEvent);
+        }
+    }
 };
-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 validateStream = (stream) => {
+    if (typeof stream?.pipe !== 'function') {
+        throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
     }
-  }
 };
-const afterMergedStreamFinished = async (onFinished, stream, {
-  signal
-}) => {
-  try {
-    await onFinished;
-    if (!signal.aborted) {
-      abortStream(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
+            })
+        ]);
     }
-  } catch (error) {
-    if (!signal.aborted) {
-      errorOrAbortStream(stream, error);
+    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 onInputStreamEnd = async ({
-  passThroughStream,
-  stream,
-  streams,
-  ended,
-  aborted,
-  controller: {
-    signal
-  }
-}) => {
-  try {
-    await (0, _promises.finished)(stream, {
-      signal,
-      cleanup: true,
-      readable: true,
-      writable: false
-    });
-    if (streams.has(stream)) {
-      ended.add(stream);
+const afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
+    try {
+        await onFinished;
+        if (!signal.aborted) {
+            abortStream(stream);
+        }
     }
-  } catch (error) {
-    if (signal.aborted || !streams.has(stream)) {
-      return;
+    catch (error) {
+        if (!signal.aborted) {
+            errorOrAbortStream(stream, error);
+        }
     }
-    if (isAbortError(error)) {
-      aborted.add(stream);
-    } else {
-      errorStream(passThroughStream, 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 (0, _nodeEvents.once)(stream, unpipeEvent, {
-    signal
-  });
-  if (!stream.readable) {
-    return (0, _nodeEvents.once)(signal, 'abort', {
-      signal
-    });
-  }
-  streams.delete(stream);
-  ended.delete(stream);
-  aborted.delete(stream);
+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 endStream = (stream) => {
+    if (stream.writable) {
+        stream.end();
+    }
 };
 const errorOrAbortStream = (stream, error) => {
-  if (isAbortError(error)) {
-    abortStream(stream);
-  } else {
-    errorStream(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();
-  }
+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);
-  }
+    if (!stream.destroyed) {
+        stream.once('error', noop);
+        stream.destroy(error);
+    }
 };
 const noop = () => {
-  // empty
+    // empty
 };
 const updateMaxListeners = (passThroughStream, increment) => {
-  const maxListeners = passThroughStream.getMaxListeners();
-  if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
-    passThroughStream.setMaxListeners(maxListeners + 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;
+const PASSTHROUGH_LISTENERS_PER_STREAM = 1;

package/dist/streams.d.ts

@@ -1,5 +1,19 @@
 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>;
@@ -13,4 +27,3 @@ export declare function readableFromArray(array: any[], options?: Partial<Readab
 export declare function collectStreamIntoArray(array?: any[], options?: Partial<WritableOptions>): Writable;
 export declare function readStreamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer>;
 export declare function batch(size: number): Transform;
-//# sourceMappingURL=streams.d.ts.map