@naturalcycles/nodejs-lib 15.25.0 → 15.27.0

package/src/stream/transform/transformLimit.ts

@@ -1,5 +1,6 @@
 import { Transform } from 'node:stream'
 import type { AbortableSignal } from '@naturalcycles/js-lib'
+import type { NonNegativeInteger } from '@naturalcycles/js-lib/types'
 import type { TransformOptions, TransformTyped } from '../stream.model.js'
 import { PIPELINE_GRACEFUL_ABORT } from '../stream.util.js'
 import { transformNoOp } from './transformNoOp.js'
@@ -8,7 +9,7 @@ export interface TransformLimitOptions extends TransformOptions {
   /**
    * Nullish value (e.g 0 or undefined) would mean "no limit"
    */
-  limit?: number
+  limit?: NonNegativeInteger
 
   /**
    * Allows to abort (gracefully stop) the stream from inside the Transform.
@@ -17,7 +18,7 @@ export interface TransformLimitOptions extends TransformOptions {
 }
 
 export function transformLimit<IN>(opt: TransformLimitOptions): TransformTyped<IN, IN> {
-  const { limit, signal } = opt
+  const { limit, signal, objectMode = true, highWaterMark } = opt
 
   if (!limit) {
     return transformNoOp()
@@ -26,8 +27,8 @@ export function transformLimit<IN>(opt: TransformLimitOptions): TransformTyped<I
   let i = 0 // so we start first chunk with 1
   let ended = false
   return new Transform({
-    objectMode: true,
-    ...opt,
+    objectMode,
+    highWaterMark,
     transform(chunk, _, cb) {
       if (ended) {
         return

package/src/stream/transform/transformLogProgress.ts

@@ -13,11 +13,12 @@ export interface TransformLogProgressOptions<IN = any>
 export function transformLogProgress<IN = any>(
   opt: TransformLogProgressOptions = {},
 ): TransformTyped<IN, IN> {
+  const { objectMode = true, highWaterMark } = opt
   const progress = progressLogger(opt)
 
   return new Transform({
-    objectMode: true,
-    ...opt,
+    objectMode,
+    highWaterMark,
     transform(chunk: IN, _, cb) {
       progress.log(chunk)
       cb(null, chunk) // pass-through

package/src/stream/transform/transformMap.ts

@@ -1,7 +1,7 @@
 import { _hc, type AbortableSignal } from '@naturalcycles/js-lib'
 import { _since } from '@naturalcycles/js-lib/datetime/time.util.js'
 import { _anyToError, _assert, ErrorMode } from '@naturalcycles/js-lib/error'
-import type { CommonLogger } from '@naturalcycles/js-lib/log'
+import { createCommonLoggerAtLevel } from '@naturalcycles/js-lib/log'
 import { _stringify } from '@naturalcycles/js-lib/string/stringify.js'
 import {
   type AbortableAsyncMapper,
@@ -15,10 +15,10 @@ import {
 } from '@naturalcycles/js-lib/types'
 import through2Concurrent from 'through2-concurrent'
 import { yellow } from '../../colors/colors.js'
-import type { TransformTyped } from '../stream.model.js'
+import type { TransformOptions, TransformTyped } from '../stream.model.js'
 import { PIPELINE_GRACEFUL_ABORT } from '../stream.util.js'
 
-export interface TransformMapOptions<IN = any, OUT = IN> {
+export interface TransformMapOptions<IN = any, OUT = IN> extends TransformOptions {
   /**
    * Predicate to filter outgoing results (after mapper).
    * Allows to not emit all results.
@@ -79,8 +79,6 @@ export interface TransformMapOptions<IN = any, OUT = IN> {
    */
   metric?: string
 
-  logger?: CommonLogger
-
   /**
    * Allows to abort (gracefully stop) the stream from inside the Transform.
    */
@@ -143,7 +141,6 @@ export function transformMap<IN = any, OUT = IN>(
     onError,
     onDone,
     metric = 'stream',
-    logger = console,
     signal,
   } = opt
 
@@ -154,6 +151,7 @@ export function transformMap<IN = any, OUT = IN>(
   let ok = true
   let errors = 0
   const collectedErrors: Error[] = [] // only used if errorMode == THROW_AGGREGATED
+  const logger = createCommonLoggerAtLevel(opt.logger, opt.logLevel)
 
   return through2Concurrent.obj(
     {
@@ -161,8 +159,6 @@ export function transformMap<IN = any, OUT = IN>(
       readableHighWaterMark: highWaterMark,
       writableHighWaterMark: highWaterMark,
       async final(cb) {
-        // console.log('transformMap final')
-
         logErrorStats(true)
 
         if (collectedErrors.length) {

package/src/stream/transform/transformMapSimple.ts

@@ -1,18 +1,15 @@
 import { Transform } from 'node:stream'
 import { ErrorMode } from '@naturalcycles/js-lib/error/errorMode.js'
-import type { CommonLogger } from '@naturalcycles/js-lib/log'
 import type { IndexedMapper } from '@naturalcycles/js-lib/types'
-import type { TransformTyped } from '../stream.model.js'
+import type { TransformOptions, TransformTyped } from '../stream.model.js'
 
-export interface TransformMapSimpleOptions {
+export interface TransformMapSimpleOptions extends TransformOptions {
   /**
    * Only supports THROW_IMMEDIATELY (default) and SUPPRESS.
    *
    * @default ErrorMode.THROW_IMMEDIATELY
    */
   errorMode?: ErrorMode.THROW_IMMEDIATELY | ErrorMode.SUPPRESS
-
-  logger?: CommonLogger
 }
 
 /**
@@ -29,10 +26,16 @@ export function transformMapSimple<IN = any, OUT = IN>(
   opt: TransformMapSimpleOptions = {},
 ): TransformTyped<IN, OUT> {
   let index = -1
-  const { errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt
+  const {
+    errorMode = ErrorMode.THROW_IMMEDIATELY,
+    logger = console,
+    objectMode = true,
+    highWaterMark,
+  } = opt
 
   return new Transform({
-    objectMode: true,
+    objectMode,
+    highWaterMark,
     transform(chunk: IN, _, cb) {
       try {
         cb(null, mapper(chunk, ++index))

package/src/stream/transform/transformMapSync.ts

@@ -1,15 +1,15 @@
 import { Transform } from 'node:stream'
 import type { AbortableSignal } from '@naturalcycles/js-lib'
 import { _anyToError, _assert, ErrorMode } from '@naturalcycles/js-lib/error'
-import type { CommonLogger } from '@naturalcycles/js-lib/log'
+import { createCommonLoggerAtLevel } from '@naturalcycles/js-lib/log'
 import type { IndexedMapper, Predicate, UnixTimestampMillis } from '@naturalcycles/js-lib/types'
 import { END, SKIP } from '@naturalcycles/js-lib/types'
 import { yellow } from '../../colors/colors.js'
-import type { TransformTyped } from '../stream.model.js'
+import type { TransformOptions, TransformTyped } from '../stream.model.js'
 import { PIPELINE_GRACEFUL_ABORT } from '../stream.util.js'
 import type { TransformMapStats } from './transformMap.js'
 
-export interface TransformMapSyncOptions<IN = any, OUT = IN> {
+export interface TransformMapSyncOptions<IN = any, OUT = IN> extends TransformOptions {
   /**
    * @default true
    */
@@ -54,8 +54,6 @@ export interface TransformMapSyncOptions<IN = any, OUT = IN> {
    */
   metric?: string
 
-  logger?: CommonLogger
-
   /**
    * Allows to abort (gracefully stop) the stream from inside the Transform.
    */
@@ -77,7 +75,6 @@ export function transformMapSync<IN = any, OUT = IN>(
     onDone,
     metric = 'stream',
     objectMode = true,
-    logger = console,
     signal,
   } = opt
 
@@ -87,6 +84,7 @@ export function transformMapSync<IN = any, OUT = IN>(
   let isSettled = false
   let errors = 0
   const collectedErrors: Error[] = [] // only used if errorMode == THROW_AGGREGATED
+  const logger = createCommonLoggerAtLevel(opt.logger, opt.logLevel)
 
   return new Transform({
     objectMode,

package/src/stream/transform/transformSplit.ts

@@ -19,7 +19,7 @@ export function transformSplitOnNewline(): TransformTyped<Buffer, Buffer> {
     writableHighWaterMark: 64 * 1024,
     readableObjectMode: true,
 
-    transform(buf: Buffer, _enc, done) {
+    transform(buf: Buffer, _enc, cb) {
       let offset = 0
       let lastMatch = 0
       if (buffered) {
@@ -42,7 +42,7 @@ export function transformSplitOnNewline(): TransformTyped<Buffer, Buffer> {
         }
       }
 
-      done()
+      cb()
     },
 
     flush(done) {

package/src/stream/transform/transformThrottle.ts

@@ -1,5 +1,6 @@
 import { Transform } from 'node:stream'
 import { _ms, _since, localTime } from '@naturalcycles/js-lib/datetime'
+import { createCommonLoggerAtLevel } from '@naturalcycles/js-lib/log'
 import type { DeferredPromise } from '@naturalcycles/js-lib/promise'
 import { pDefer } from '@naturalcycles/js-lib/promise/pDefer.js'
 import type {
@@ -7,9 +8,9 @@ import type {
   PositiveInteger,
   UnixTimestampMillis,
 } from '@naturalcycles/js-lib/types'
-import type { TransformTyped } from '../stream.model.js'
+import type { TransformOptions, TransformTyped } from '../stream.model.js'
 
-export interface TransformThrottleOptions {
+export interface TransformThrottleOptions extends TransformOptions {
   /**
    * How many items to allow per `interval` of seconds.
    */
@@ -19,8 +20,6 @@ export interface TransformThrottleOptions {
    * How long is the interval (in seconds) where number of items should not exceed `throughput`.
    */
   interval: NumberOfSeconds
-
-  debug?: boolean
 }
 
 /**
@@ -41,42 +40,40 @@ export interface TransformThrottleOptions {
  * @experimental
  */
 export function transformThrottle<T>(opt: TransformThrottleOptions): TransformTyped<T, T> {
-  const { throughput, interval, debug } = opt
+  const { throughput, interval, objectMode = true, highWaterMark } = opt
 
   let count = 0
   let start: UnixTimestampMillis
-  let paused: DeferredPromise | undefined
+  let lock: DeferredPromise | undefined
   let timeout: NodeJS.Timeout | undefined
+  const logger = createCommonLoggerAtLevel(opt.logger, opt.logLevel)
 
   return new Transform({
-    objectMode: true,
+    objectMode,
+    highWaterMark,
     async transform(item: T, _, cb) {
       // console.log('incoming', item, { paused: !!paused, count })
       if (!start) {
         start = Date.now() as UnixTimestampMillis
         timeout = setTimeout(() => onInterval(this), interval * 1000)
-        if (debug) {
-          console.log(`${localTime.now().toPretty()} transformThrottle started with`, {
-            throughput,
-            interval,
-            rps: Math.round(throughput / interval),
-          })
-        }
+        logger.log(`${localTime.now().toPretty()} transformThrottle started with`, {
+          throughput,
+          interval,
+          rps: Math.round(throughput / interval),
+        })
       }
 
-      if (paused) {
-        // console.log('awaiting pause', {item, count})
-        await paused
+      if (lock) {
+        // console.log('awaiting lock', {item, count})
+        await lock
       }
 
       if (++count >= throughput) {
         // console.log('pausing now after', {item, count})
-        paused = pDefer()
-        if (debug) {
-          console.log(
-            `${localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${_since(start)}, will pause for ${_ms(interval * 1000 - (Date.now() - start))}`,
-          )
-        }
+        lock = pDefer()
+        logger.log(
+          `${localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${_since(start)}, will pause for ${_ms(interval * 1000 - (Date.now() - start))}`,
+        )
       }
 
       cb(null, item) // pass the item through
@@ -88,23 +85,18 @@ export function transformThrottle<T>(opt: TransformThrottleOptions): TransformTy
   })
 
   function onInterval(transform: Transform): void {
-    if (paused) {
-      if (debug) {
-        console.log(`${localTime.now().toPretty()} transformThrottle resumed`)
-      }
-
-      paused.resolve()
-      paused = undefined
+    if (lock) {
+      logger.log(`${localTime.now().toPretty()} transformThrottle resumed`)
+      lock.resolve()
+      lock = undefined
     } else {
-      if (debug) {
-        console.log(
-          `${localTime.now().toPretty()} transformThrottle passed ${count} (of max ${throughput}) items in ${_since(start)}`,
-        )
-      }
+      logger.log(
+        `${localTime.now().toPretty()} transformThrottle passed ${count} (of max ${throughput}) items in ${_since(start)}`,
+      )
     }
 
     count = 0
-    start = Date.now() as UnixTimestampMillis
+    start = localTime.nowUnixMillis()
     timeout = setTimeout(() => onInterval(transform), interval * 1000)
   }
 }

package/src/stream/writable/writableVoid.ts

@@ -1,20 +1,12 @@
 import { Writable } from 'node:stream'
-import type { DeferredPromise } from '@naturalcycles/js-lib/promise'
 import type { TransformOptions } from '../stream.model.js'
 
-export interface WritableVoidOptions extends TransformOptions {
-  /**
-   * If set - it will be Resolved when the Stream is done (after final.cb)
-   */
-  streamDone?: DeferredPromise
-}
-
 /**
  * Use as a "null-terminator" of stream.pipeline.
  * It consumes the stream as quickly as possible without doing anything.
  * Put it in the end of your pipeline in case it ends with Transform that needs a consumer.
  */
-export function writableVoid(opt: WritableVoidOptions = {}): Writable {
+export function writableVoid(opt: TransformOptions = {}): Writable {
   return new Writable({
     objectMode: true,
     ...opt,
@@ -23,7 +15,6 @@ export function writableVoid(opt: WritableVoidOptions = {}): Writable {
     },
     final(cb) {
       cb()
-      opt.streamDone?.resolve()
     },
   })
 }

package/dist/stream/ndjson/createReadStreamAsNDJSON.d.ts

@@ -1,19 +0,0 @@
-import type { ReadableTyped } from '../stream.model.js';
-/**
-  Returns a Readable of [already parsed] NDJSON objects.
- 
-  Replaces a list of operations:
-  - requireFileToExist(inputPath)
-  - fs.createReadStream
-  - createUnzip (only if path ends with '.gz')
-  - transformSplitOnNewline
-  - transformJsonParse
- 
-  To add a Limit or Offset: just add .take() or .drop(), example:
- 
-  _pipeline([
-    fs2.createReadStreamAsNDJSON().take(100),
-    transformX(),
-  ])
- */
-export declare function createReadStreamAsNDJSON<ROW = any>(inputPath: string): ReadableTyped<ROW>;

package/dist/stream/ndjson/createWriteStreamAsNDJSON.d.ts

@@ -1,11 +0,0 @@
-import type { TransformTyped } from '../stream.model.js';
-/**
-  Returns an array of Transforms, so that you can ...destructure them at
-  the end of the _pipeline.
- 
-  Replaces a list of operations:
-  - transformToNDJson
-  - createGzip (only if path ends with '.gz')
-  - fs.createWriteStream
- */
-export declare function createWriteStreamAsNDJSON(outputPath: string): TransformTyped<any, any>[];

package/dist/stream/ndjson/createWriteStreamAsNDJSON.js

@@ -1,27 +0,0 @@
-import { createGzip } from 'node:zlib';
-import { _isTruthy } from '@naturalcycles/js-lib';
-import { fs2 } from '../../fs/fs2.js';
-import { transformToNDJson } from './transformToNDJson.js';
-/**
-  Returns an array of Transforms, so that you can ...destructure them at
-  the end of the _pipeline.
- 
-  Replaces a list of operations:
-  - transformToNDJson
-  - createGzip (only if path ends with '.gz')
-  - fs.createWriteStream
- */
-export function createWriteStreamAsNDJSON(outputPath) {
-    fs2.ensureFile(outputPath);
-    return [
-        transformToNDJson(),
-        outputPath.endsWith('.gz')
-            ? createGzip({
-            // chunkSize: 64 * 1024, // no observed speedup
-            })
-            : undefined,
-        fs2.createWriteStream(outputPath, {
-        // highWaterMark: 64 * 1024, // no observed speedup
-        }),
-    ].filter(_isTruthy);
-}

package/dist/stream/ndjson/ndjsonStreamForEach.d.ts

@@ -1,10 +0,0 @@
-import type { AbortableAsyncMapper } from '@naturalcycles/js-lib/types';
-import type { TransformLogProgressOptions } from '../transform/transformLogProgress.js';
-import type { TransformMapOptions } from '../transform/transformMap.js';
-export interface NDJSONStreamForEachOptions<IN = any> extends TransformMapOptions<IN, void>, TransformLogProgressOptions<IN> {
-    inputFilePath: string;
-}
-/**
- * Convenience function to `forEach` through an ndjson file.
- */
-export declare function ndjsonStreamForEach<T>(mapper: AbortableAsyncMapper<T, void>, opt: NDJSONStreamForEachOptions<T>): Promise<void>;

package/dist/stream/ndjson/ndjsonStreamForEach.js

@@ -1,15 +0,0 @@
-import { ErrorMode } from '@naturalcycles/js-lib/error/errorMode.js';
-import { Pipeline } from '../pipeline.js';
-/**
- * Convenience function to `forEach` through an ndjson file.
- */
-export async function ndjsonStreamForEach(mapper, opt) {
-    await Pipeline.fromNDJsonFile(opt.inputFilePath)
-        .map(mapper, {
-        errorMode: ErrorMode.THROW_AGGREGATED,
-        ...opt,
-        predicate: () => true, // to log progress properly
-    })
-        .logProgress(opt)
-        .run();
-}

package/dist/stream/readable/readableToArray.d.ts

@@ -1,9 +0,0 @@
-import type { ReadableTyped } from '../stream.model.js';
-/**
- * Convenience function to read the whole Readable stream into Array (in-memory)
- * and return that array.
- *
- * Native `await readable.toArray()` can be used instead.
- * This helper is kept for type-safery support.
- */
-export declare function readableToArray<T>(readable: ReadableTyped<T>): Promise<T[]>;

package/dist/stream/readable/readableToArray.js

@@ -1,17 +0,0 @@
-/**
- * Convenience function to read the whole Readable stream into Array (in-memory)
- * and return that array.
- *
- * Native `await readable.toArray()` can be used instead.
- * This helper is kept for type-safery support.
- */
-export async function readableToArray(readable) {
-    return await readable.toArray();
-    // const a: T[] = []
-    //
-    // for await (const item of readable) {
-    //   a.push(item)
-    // }
-    //
-    // return a
-}

package/dist/stream/transform/transformTee.d.ts

@@ -1,13 +0,0 @@
-import type { TransformTyped } from '../stream.model.js';
-type AnyStream = NodeJS.WritableStream | NodeJS.ReadWriteStream;
-/**
- * Allows to "tee"/"fork" away from the "main pipeline" into the "secondary pipeline".
- *
- * Important, that the main pipeline works "as normal", keeps backpressure, etc.
- * Secondary pipeline DOES NOT keep backpressure.
- * Therefor, the "slowest" pipeline should be made Primary (to keep backpressure).
- *
- * @experimental
- */
-export declare function transformTee<T>(streams: AnyStream[]): TransformTyped<T, T>;
-export {};

package/dist/stream/transform/transformTee.js

@@ -1,37 +0,0 @@
-import { Transform } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { readableCreate } from '../readable/readableCreate.js';
-/**
- * Allows to "tee"/"fork" away from the "main pipeline" into the "secondary pipeline".
- *
- * Important, that the main pipeline works "as normal", keeps backpressure, etc.
- * Secondary pipeline DOES NOT keep backpressure.
- * Therefor, the "slowest" pipeline should be made Primary (to keep backpressure).
- *
- * @experimental
- */
-export function transformTee(streams) {
-    const readable = readableCreate();
-    const secondPipelinePromise = pipeline([readable, ...streams]);
-    return new Transform({
-        objectMode: true,
-        transform(chunk, _, cb) {
-            // todo: it's possible to start respecting backpressure,
-            // if we start to listen to the boolean output of .push()
-            // pass to the "secondary" pipeline
-            readable.push(chunk);
-            // pass through to the "main" pipeline
-            cb(null, chunk);
-        },
-        async final(cb) {
-            console.log('transformTee final');
-            // Pushing null "closes"/ends the secondary pipeline correctly
-            readable.push(null);
-            // Second pipeline is expected to finish now, let's await it
-            await secondPipelinePromise;
-            console.log('transformTee final secondPipeline done');
-            // Because second pipeline is done - now we can signal main pipeline to be done as well
-            cb();
-        },
-    });
-}

package/dist/stream/transform/transformToArray.d.ts

@@ -1,5 +0,0 @@
-import type { TransformOptions, TransformTyped } from '../stream.model.js';
-/**
- * Will collect all stream results in the array (keeping it in memory) and emit in the end as one result.
- */
-export declare function transformToArray<IN>(opt?: TransformOptions): TransformTyped<IN, IN[]>;

package/dist/stream/transform/transformToArray.js

@@ -1,20 +0,0 @@
-import { Transform } from 'node:stream';
-/**
- * Will collect all stream results in the array (keeping it in memory) and emit in the end as one result.
- */
-export function transformToArray(opt = {}) {
-    const res = [];
-    return new Transform({
-        objectMode: true,
-        ...opt,
-        transform(chunk, _, cb) {
-            res.push(chunk);
-            // callback to signal that we processed input, but not emitting any output
-            cb();
-        },
-        final(cb) {
-            this.push(res);
-            cb();
-        },
-    });
-}

package/dist/stream/writable/writableForEach.d.ts

@@ -1,12 +0,0 @@
-import type { AsyncIndexedMapper, IndexedMapper } from '@naturalcycles/js-lib/types';
-import type { WritableTyped } from '../stream.model.js';
-import { type TransformMapOptions } from '../transform/transformMap.js';
-import { type TransformMapSyncOptions } from '../transform/transformMapSync.js';
-/**
- * Just an alias to transformMap that declares OUT as void.
- */
-export declare function writableForEach<IN = any>(mapper: AsyncIndexedMapper<IN, void>, opt?: TransformMapOptions<IN, void>): WritableTyped<IN>;
-/**
- * Just an alias to transformMap that declares OUT as void.
- */
-export declare function writableForEachSync<IN = any>(mapper: IndexedMapper<IN, void>, opt?: TransformMapSyncOptions<IN, void>): WritableTyped<IN>;

package/dist/stream/writable/writableForEach.js

@@ -1,15 +0,0 @@
-import { _passNothingPredicate } from '@naturalcycles/js-lib/types';
-import { transformMap } from '../transform/transformMap.js';
-import { transformMapSync } from '../transform/transformMapSync.js';
-/**
- * Just an alias to transformMap that declares OUT as void.
- */
-export function writableForEach(mapper, opt = {}) {
-    return transformMap(mapper, { ...opt, predicate: _passNothingPredicate });
-}
-/**
- * Just an alias to transformMap that declares OUT as void.
- */
-export function writableForEachSync(mapper, opt = {}) {
-    return transformMapSync(mapper, { ...opt, predicate: _passNothingPredicate });
-}

package/dist/stream/writable/writableFork.d.ts

@@ -1,10 +0,0 @@
-import type { TransformOptions, WritableTyped } from '../stream.model.js';
-/**
- * Allows "forking" a stream inside pipeline into a number of pipeline chains (2 or more).
- * Currently does NOT (!) maintain backpressure.
- * Error in the forked pipeline will propagate up to the main pipeline (and log error, to be sure).
- * Will wait until all forked pipelines are completed before completing the stream.
- *
- * @experimental
- */
-export declare function writableFork<T>(chains: NodeJS.WritableStream[][], opt?: TransformOptions): WritableTyped<T>;

package/dist/stream/writable/writableFork.js

@@ -1,45 +0,0 @@
-import { Writable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { readableCreate } from '../readable/readableCreate.js';
-/**
- * Allows "forking" a stream inside pipeline into a number of pipeline chains (2 or more).
- * Currently does NOT (!) maintain backpressure.
- * Error in the forked pipeline will propagate up to the main pipeline (and log error, to be sure).
- * Will wait until all forked pipelines are completed before completing the stream.
- *
- * @experimental
- */
-export function writableFork(chains, opt) {
-    const readables = [];
-    const allChainsDone = Promise.all(chains.map(async (chain) => {
-        const readable = readableCreate();
-        readables.push(readable);
-        return await pipeline([readable, ...chain]);
-    })).catch(err => {
-        console.error(err); // ensure the error is logged
-        throw err;
-    });
-    return new Writable({
-        objectMode: true,
-        ...opt,
-        write(chunk, _, cb) {
-            // Push/fork to all sub-streams
-            // No backpressure is ensured here, it'll push regardless of the
-            readables.forEach(readable => readable.push(chunk));
-            cb();
-        },
-        async final(cb) {
-            try {
-                // Push null (complete) to all sub-streams
-                readables.forEach(readable => readable.push(null));
-                console.log(`writableFork.final is waiting for all chains to be done`);
-                await allChainsDone;
-                console.log(`writableFork.final all chains done`);
-                cb();
-            }
-            catch (err) {
-                cb(err);
-            }
-        },
-    });
-}

package/dist/stream/writable/writableLimit.d.ts

@@ -1,8 +0,0 @@
-import type { Readable } from 'node:stream';
-import type { WritableTyped } from '../stream.model.js';
-/**
- * Allows to stop the Readable stream after the pipeline has processed X number of rows.
- * It counts OUTPUT rows (not input), because this Writable is always at the end of the Pipeline.
- * It ensures that everything has been processed before issuing a STOP on the readable.
- */
-export declare function writableLimit<T>(readable: Readable, limit: number): WritableTyped<T>;