@naturalcycles/nodejs-lib 12.58.0 → 12.62.0

package/dist/stream/ndjson/ndjsonMap.js

@@ -18,19 +18,20 @@ async function ndjsonMap(mapper, opt) {
     });
     const transformUnzip = inputFilePath.endsWith('.gz') ? [(0, zlib_1.createUnzip)()] : [];
     const transformZip = outputFilePath.endsWith('.gz') ? [(0, zlib_1.createGzip)()] : [];
+    const readable = (0, fs_1.createReadStream)(inputFilePath);
     await (0, __1._pipeline)([
-        (0, fs_1.createReadStream)(inputFilePath),
+        readable,
         ...transformUnzip,
         (0, __1.transformSplit)(),
         (0, __1.transformJsonParse)(),
-        (0, __1.transformLimit)(limitInput),
+        (0, __1.transformLimit)({ limit: limitInput, sourceReadable: readable }),
         (0, __1.transformLogProgress)({ metric: 'read', ...opt }),
         (0, __1.transformMap)(mapper, {
             flattenArrayOutput: true,
             errorMode: js_lib_1.ErrorMode.SUPPRESS,
             ...opt,
         }),
-        (0, __1.transformLimit)(limitOutput),
+        (0, __1.transformLimit)({ limit: limitOutput, sourceReadable: readable }),
         (0, __1.transformLogProgress)({ metric: 'saved', logEvery: logEveryOutput }),
         (0, __1.transformToNDJson)(),
         ...transformZip,

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

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

package/dist/stream/ndjson/transformJsonParse.js

@@ -19,19 +19,19 @@ const stream_1 = require("stream");
 function transformJsonParse(opt = {}) {
     const { strict = true, reviver } = opt;
     return new stream_1.Transform({
-        objectMode: false,
+        writableObjectMode: false,
         readableObjectMode: true,
-        transform(chunk, _encoding, cb) {
+        transform(chunk, _, cb) {
             try {
                 const data = JSON.parse(chunk, reviver);
                 cb(null, data);
             }
             catch (err) {
-                // console.error(err)
                 if (strict) {
                     cb(err); // emit error
                 }
                 else {
+                    console.error(err);
                     cb(); // emit no error, but no result neither
                 }
             }

package/dist/stream/ndjson/transformToNDJson.js

@@ -9,9 +9,9 @@ const js_lib_1 = require("@naturalcycles/js-lib");
 function transformToNDJson(opt = {}) {
     const { strict = true, separator = '\n', sortObjects = false, useFlatstr = false } = opt;
     return new stream_1.Transform({
-        objectMode: true,
+        writableObjectMode: true,
         readableObjectMode: false,
-        transform(chunk, _encoding, cb) {
+        transform(chunk, _, cb) {
             try {
                 if (sortObjects) {
                     chunk = (0, js_lib_1._sortObjectDeep)(chunk);

package/dist/stream/pipeline/pipeline.d.ts

@@ -1,6 +1,28 @@
 /// <reference types="node" />
-import { pipeline } from 'stream';
+import { Readable, Transform } from 'stream';
+import { DeferredPromise } from '@naturalcycles/js-lib';
+declare type AnyStream = NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream;
+export interface PipelineOptions {
+    /**
+     * Set to true to allow ERR_STREAM_PREMATURE_CLOSE.
+     * Required to support graceful close when using transformLimit
+     */
+    allowClose?: boolean;
+}
 /**
- * Promisified stream.pipeline()
+ * Promisified `stream.pipeline`.
+ *
+ * Supports opt.allowClose, which allows transformLimit to work (to actually stop source Readable)
+ * without throwing an error (ERR_STREAM_PREMATURE_CLOSE).
  */
-export declare let _pipeline: typeof pipeline.__promisify__;
+export declare function _pipeline(streams: AnyStream[], opt?: PipelineOptions): Promise<void>;
+/**
+ * Convenience function to make _pipeline collect all items at the end of the stream (should be Transform, not Writeable!)
+ * and return.
+ */
+export declare function _pipelineToArray<T>(streams: AnyStream[], opt?: PipelineOptions): Promise<T[]>;
+export declare class AbortableTransform extends Transform {
+    sourceReadable?: Readable;
+    streamDone?: DeferredPromise;
+}
+export {};

package/dist/stream/pipeline/pipeline.js

@@ -1,15 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._pipeline = void 0;
+exports.AbortableTransform = exports._pipelineToArray = exports._pipeline = void 0;
 const stream_1 = require("stream");
-const util_1 = require("util");
+const js_lib_1 = require("@naturalcycles/js-lib");
+const index_1 = require("../../index");
 /**
- * Promisified stream.pipeline()
+ * Promisified `stream.pipeline`.
+ *
+ * Supports opt.allowClose, which allows transformLimit to work (to actually stop source Readable)
+ * without throwing an error (ERR_STREAM_PREMATURE_CLOSE).
  */
-exports._pipeline = (0, util_1.promisify)(stream_1.pipeline);
-// Workaround https://github.com/nodejs/node/issues/40191
-// todo: remove it when fix is released in 16.x and in AppEngine 16.x
-if (process.version >= 'v16.10') {
-    const { pipeline } = require('stream/promises');
-    exports._pipeline = ((streams) => pipeline(...streams));
+async function _pipeline(streams, opt = {}) {
+    const first = streams[0];
+    const rest = streams.slice(1);
+    if (opt.allowClose) {
+        // Do the magic of making the pipeline "abortable"
+        //
+        // How does it work:
+        // It finds `sourceReadable` (basically, it's just first item in the passed array of streams)
+        // Finds last "writable" (last item), patches the `_final` method of it to detect when the whole pipeline is "done",
+        // sets the `streamDone` DeferredPromise that resolves when the pipeline is done.
+        // Scans through all passed items, finds those that are capable of "closing" the stream
+        // (currently its `transformLimit` or `transformMap`)
+        // Patches them by attaching `sourceReadable` and `streamDone`.
+        // These items (transformLimit and transformMap), when they need to "close the stream" - call `pipelineClose`.
+        // `pipelineClose` is the result of 2 sleepless nights of googling and experimentation:)
+        // It does:
+        // 1. Stops the "downstream" by doing `this.push(null)`.
+        // 2. Pauses the `sourceReadable` by calling sourceReadable.unpipe()
+        // 3. Waits for `streamDone` to ensure that downstream chunks are fully processed (e.g written to disk).
+        // 4. Calls `sourceReadable.destroy()`, which emits ERR_STREAM_PREMATURE_CLOSE
+        // 5. _pipeline (this function) catches that specific error and suppresses it (because it's expected and
+        // inevitable in this flow). Know a better way to close the stream? Tell me!
+        const streamDone = (0, js_lib_1.pDefer)();
+        const sourceReadable = first;
+        const last = (0, js_lib_1._last)(streams);
+        const lastFinal = last._final?.bind(last) || ((cb) => cb());
+        last._final = cb => {
+            lastFinal(() => {
+                cb();
+                streamDone.resolve();
+            });
+        };
+        rest.forEach(s => {
+            // console.log(s)
+            if (s instanceof AbortableTransform || s.constructor.name === 'DestroyableTransform') {
+                // console.log(`found ${s.constructor.name}, setting props`)
+                ;
+                s.sourceReadable = sourceReadable;
+                s.streamDone = streamDone;
+            }
+        });
+    }
+    return new Promise((resolve, reject) => {
+        (0, stream_1.pipeline)(first, ...rest, (err) => {
+            if (err) {
+                if (opt.allowClose && err?.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+                    console.log('_pipeline closed (as expected)');
+                    return resolve();
+                }
+                // console.log(`_pipeline error`, err)
+                return reject(err);
+            }
+            resolve();
+        });
+    });
 }
+exports._pipeline = _pipeline;
+/**
+ * Convenience function to make _pipeline collect all items at the end of the stream (should be Transform, not Writeable!)
+ * and return.
+ */
+async function _pipelineToArray(streams, opt = {}) {
+    const a = [];
+    await _pipeline([...streams, (0, index_1.writablePushToArray)(a)], opt);
+    return a;
+}
+exports._pipelineToArray = _pipelineToArray;
+class AbortableTransform extends stream_1.Transform {
+}
+exports.AbortableTransform = AbortableTransform;

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

@@ -6,6 +6,14 @@ import { ReadableTyped } from '../stream.model';
  * Push `null` to it to complete (similar to RxJS `.complete()`).
  *
  * Difference from Readable.from() is that this readable is not "finished" yet and allows pushing more to it.
+ *
+ * Caution!
+ * The implementation of this Readable is not fully compliant,
+ * e.g the read() method doesn't return anything, so, it will hand the Node process (or cause it to process.exit(0))
+ * if read() will be called AFTER everything was pushed and Readable is closed (by pushing `null`).
+ * Beware of it when e.g doing unit testing! Jest prefers to hang (not exit-0).
+ *
+ * @deprecated because of the caution above
  */
 export declare function readableCreate<T>(items?: Iterable<T>, opt?: ReadableOptions): ReadableTyped<T>;
 /**

package/dist/stream/readable/readableCreate.js

@@ -7,12 +7,20 @@ const stream_1 = require("stream");
  * Push `null` to it to complete (similar to RxJS `.complete()`).
  *
  * Difference from Readable.from() is that this readable is not "finished" yet and allows pushing more to it.
+ *
+ * Caution!
+ * The implementation of this Readable is not fully compliant,
+ * e.g the read() method doesn't return anything, so, it will hand the Node process (or cause it to process.exit(0))
+ * if read() will be called AFTER everything was pushed and Readable is closed (by pushing `null`).
+ * Beware of it when e.g doing unit testing! Jest prefers to hang (not exit-0).
+ *
+ * @deprecated because of the caution above
  */
 function readableCreate(items = [], opt) {
     const readable = new stream_1.Readable({
         objectMode: true,
         ...opt,
-        read() { },
+        read() { }, // Caution, if this is called and Readable has not finished yet (null wasn't pushed) - it'll hang the process!
     });
     for (const item of items) {
         readable.push(item);

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

@@ -1,4 +1,4 @@
-import { AsyncMapper, Mapper } from '@naturalcycles/js-lib';
+import { Mapper, AbortableAsyncMapper } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '../../index';
 import { TransformMapOptions } from '../transform/transformMap';
 /**
@@ -7,7 +7,7 @@ import { TransformMapOptions } from '../transform/transformMap';
  *
  * @experimental
  */
-export declare function readableForEach<T>(readable: ReadableTyped<T>, mapper: AsyncMapper<T, void>, opt?: TransformMapOptions<T, void>): Promise<void>;
+export declare function readableForEach<T>(readable: ReadableTyped<T>, mapper: AbortableAsyncMapper<T, void>, opt?: TransformMapOptions<T, void>): Promise<void>;
 /**
  * Convenience function to do `.forEach` over a Readable.
  * Typed! (unlike default Readable).

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { ReadableOptions } from 'stream';
-import { AsyncMapper } from '@naturalcycles/js-lib';
+import { AbortableAsyncMapper } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '../stream.model';
 /**
  * Create Readable from Array.
@@ -8,4 +8,4 @@ import { ReadableTyped } from '../stream.model';
  *
  * For simple cases use Readable.from(...) (Node.js 12+)
  */
-export declare function readableFromArray<IN, OUT>(items: IN[], mapper?: AsyncMapper<IN, OUT>, opt?: ReadableOptions): ReadableTyped<OUT>;
+export declare function readableFromArray<IN, OUT>(items: IN[], mapper?: AbortableAsyncMapper<IN, OUT>, opt?: ReadableOptions): ReadableTyped<OUT>;

package/dist/stream/readable/readableFromArray.js

@@ -10,21 +10,25 @@ const js_lib_1 = require("@naturalcycles/js-lib");
  * For simple cases use Readable.from(...) (Node.js 12+)
  */
 function readableFromArray(items, mapper = js_lib_1._passthroughMapper, opt) {
-    const readable = new stream_1.Readable({
+    let i = -1;
+    return new stream_1.Readable({
         objectMode: true,
         ...opt,
-        read() { },
+        async read() {
+            i++;
+            if (i < items.length) {
+                try {
+                    this.push(await mapper(items[i], i));
+                }
+                catch (err) {
+                    console.error(err);
+                    this.destroy(err);
+                }
+            }
+            else {
+                this.push(null); // end
+            }
+        },
     });
-    void (0, js_lib_1.pMap)(items, async (item, index) => {
-        readable.push(await mapper(item, index));
-    }, { concurrency: 1 })
-        .then(() => {
-        readable.push(null); // done
-    })
-        .catch(err => {
-        console.error(err);
-        readable.push(err);
-    });
-    return readable;
 }
 exports.readableFromArray = readableFromArray;

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

@@ -1,3 +1,3 @@
-import { AsyncMapper } from '@naturalcycles/js-lib';
+import { AbortableAsyncMapper } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '../stream.model';
-export declare function readableMap<IN, OUT>(readable: ReadableTyped<IN>, mapper: AsyncMapper<IN, OUT>): ReadableTyped<OUT>;
+export declare function readableMap<IN, OUT>(readable: ReadableTyped<IN>, mapper: AbortableAsyncMapper<IN, OUT>): ReadableTyped<OUT>;

package/dist/stream/readable/readableMap.js

@@ -1,24 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readableMap = void 0;
-const index_1 = require("../../index");
+const stream_1 = require("stream");
+const js_lib_1 = require("@naturalcycles/js-lib");
 function readableMap(readable, mapper) {
-    const out = (0, index_1.readableCreate)();
-    void (async () => {
-        try {
-            let index = 0;
-            for await (const item of readable) {
-                const v = await mapper(item, index++);
-                out.push(v);
+    let i = -1;
+    // todo: check if we need to handle errors somehow specifically
+    return readable.pipe(new stream_1.Transform({
+        objectMode: true,
+        async transform(chunk, _enc, cb) {
+            try {
+                const r = await mapper(chunk, ++i);
+                if (r === js_lib_1.SKIP) {
+                    cb();
+                }
+                else {
+                    // _assert(r !== END, `readableMap END not supported`)
+                    cb(null, r);
+                }
             }
-            // We're done
-            out.push(null);
-        }
-        catch (err) {
-            console.error(err);
-            out.emit('error', err);
-        }
-    })();
-    return out;
+            catch (err) {
+                console.error(err);
+                cb(err);
+            }
+        },
+    }));
 }
 exports.readableMap = readableMap;

package/dist/stream/sizeStack.d.ts

@@ -0,0 +1,9 @@
+import { CommonLogger, NumberStack } from '@naturalcycles/js-lib';
+export declare class SizeStack extends NumberStack {
+    name: string;
+    constructor(name: string, size: number);
+    total: number;
+    push(item: any): this;
+    getStats(): string;
+    static countItem(item: any, logger: CommonLogger, sizes?: SizeStack, sizesZipped?: SizeStack): Promise<void>;
+}

package/dist/stream/sizeStack.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizeStack = void 0;
+const js_lib_1 = require("@naturalcycles/js-lib");
+const colors_1 = require("../colors");
+const zip_util_1 = require("../util/zip.util");
+class SizeStack extends js_lib_1.NumberStack {
+    constructor(name, size) {
+        super(size);
+        this.name = name;
+        this.total = 0;
+    }
+    push(item) {
+        this.total += item;
+        return super.push(item);
+    }
+    getStats() {
+        // const pcs = this.percentiles([50, 90])
+        return [
+            '  ' + this.name,
+            'avg',
+            (0, colors_1.yellow)((0, js_lib_1._hb)(this.avg())),
+            // 'p50',
+            // yellow(_hb(pcs[50])),
+            // 'p90',
+            // yellow(_hb(pcs[90])),
+            'total',
+            (0, colors_1.yellow)((0, js_lib_1._hb)(this.total)),
+        ].join(' ');
+    }
+    static async countItem(item, logger, sizes, sizesZipped) {
+        if (!sizes)
+            return;
+        // try-catch, because we don't want to fail the pipeline on logProgress
+        try {
+            const buf = Buffer.from(JSON.stringify(item));
+            sizes.push(buf.byteLength);
+            if (sizesZipped) {
+                const { byteLength } = await (0, zip_util_1.gzipBuffer)(buf);
+                sizesZipped.push(byteLength);
+            }
+        }
+        catch (err) {
+            logger.warn(`transformLogProgress failed to JSON.stringify the chunk: ${err.message}`);
+        }
+    }
+}
+exports.SizeStack = SizeStack;

package/dist/stream/stream.util.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { CommonLogger } from '@naturalcycles/js-lib';
+export declare function pipelineClose(name: string, readableDownstream: Readable, sourceReadable: Readable | undefined, streamDone: Promise<void> | undefined, logger: CommonLogger): void;

package/dist/stream/stream.util.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipelineClose = void 0;
+function pipelineClose(name, readableDownstream, sourceReadable, streamDone, logger) {
+    readableDownstream.push(null); // this closes the stream, so downstream Readable will receive `end` and won't write anything
+    if (!sourceReadable) {
+        logger.warn(`${name} sourceReadable is not provided, readable stream will not be stopped`);
+    }
+    else {
+        logger.log(`${name} is calling readable.unpipe() to pause the stream`);
+        sourceReadable.unpipe(); // it is expected to pause the stream
+        if (!streamDone) {
+            logger.log(`${name} streamDone is not provided, will do readable.destroy right away`);
+            sourceReadable.destroy();
+        }
+        else {
+            void streamDone.then(() => {
+                logger.log(`${name} streamDone, calling readable.destroy()`);
+                sourceReadable.destroy(); // this throws ERR_STREAM_PREMATURE_CLOSE
+            });
+        }
+    }
+}
+exports.pipelineClose = pipelineClose;

package/dist/stream/transform/transformBuffer.js

@@ -13,7 +13,7 @@ function transformBuffer(opt) {
     return new stream_1.Transform({
         objectMode: true,
         ...opt,
-        transform(chunk, _encoding, cb) {
+        transform(chunk, _, cb) {
             buf.push(chunk);
             if (buf.length >= batchSize) {
                 cb(null, buf);

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

@@ -1,11 +1,10 @@
 import { AsyncPredicate, Predicate } from '@naturalcycles/js-lib';
 import { TransformOptions, TransformTyped } from '../stream.model';
+import { TransformMapOptions } from './transformMap';
 /**
- * Note, that currently it's NOT concurrent! (concurrency = 1)
- * So, it's recommended to use transformMap instead, that is both concurrent and has
- * filtering feature by default.
+ * Just a convenience wrapper around `transformMap` that has built-in predicate filtering support.
  */
-export declare function transformFilter<IN = any>(predicate: AsyncPredicate<IN>, opt?: TransformOptions): TransformTyped<IN, IN>;
+export declare function transformFilter<IN = any>(predicate: AsyncPredicate<IN>, opt?: TransformMapOptions): TransformTyped<IN, IN>;
 /**
  * Sync version of `transformFilter`
  */

package/dist/stream/transform/transformFilter.js

@@ -2,29 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformFilterSync = exports.transformFilter = void 0;
 const stream_1 = require("stream");
+const transformMap_1 = require("./transformMap");
 /**
- * Note, that currently it's NOT concurrent! (concurrency = 1)
- * So, it's recommended to use transformMap instead, that is both concurrent and has
- * filtering feature by default.
+ * Just a convenience wrapper around `transformMap` that has built-in predicate filtering support.
  */
 function transformFilter(predicate, opt = {}) {
-    let index = 0;
-    return new stream_1.Transform({
-        objectMode: true,
+    return (0, transformMap_1.transformMap)(v => v, {
+        predicate,
         ...opt,
-        async transform(chunk, _encoding, cb) {
-            try {
-                if (await predicate(chunk, index++)) {
-                    cb(null, chunk); // pass through
-                }
-                else {
-                    cb(); // signal that we've finished processing, but emit no output here
-                }
-            }
-            catch (err) {
-                cb(err);
-            }
-        },
     });
 }
 exports.transformFilter = transformFilter;
@@ -36,7 +21,7 @@ function transformFilterSync(predicate, opt = {}) {
     return new stream_1.Transform({
         objectMode: true,
         ...opt,
-        async transform(chunk, _encoding, cb) {
+        transform(chunk, _, cb) {
             try {
                 if (predicate(chunk, index++)) {
                     cb(null, chunk); // pass through

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

@@ -1,9 +1,40 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
 import { CommonLogger } from '@naturalcycles/js-lib';
+import { AbortableTransform } from '../../index';
 import { TransformOptions, TransformTyped } from '../stream.model';
 export interface TransformLimitOptions extends TransformOptions {
+    /**
+     * Nullish value (e.g 0 or undefined) would mean "no limit"
+     */
+    limit?: number;
+    /**
+     * If provided (recommended!) - it will call readable.destroy() on limit.
+     * Without it - it will only stop the downstream consumers, but won't stop
+     * the Readable ("source" of the stream).
+     * It is almost always crucial to stop the Source too, so, please provide the Readable here!
+     */
+    sourceReadable?: Readable;
+    /**
+     * Please provide it (a Promise that resolves when the Stream is done, e.g finished consuming things)
+     * to be able to wait for Consumers before calling `readable.destroy`.
+     * Has no effect if `readable` is not provided.
+     */
+    streamDone?: Promise<void>;
     logger?: CommonLogger;
+    /**
+     * Set to true to enable additional debug messages, e.g it'll log
+     * when readable still emits values after the limit is reached.
+     */
+    debug?: boolean;
+}
+/**
+ * Class only exists to be able to do `instanceof TransformLimit`
+ * and to set sourceReadable+streamDone to it in `_pipeline`.
+ */
+export declare class TransformLimit extends AbortableTransform {
 }
 /**
  * 0 or falsy value means "no limit"
  */
-export declare function transformLimit<IN>(limit?: number, opt?: TransformLimitOptions): TransformTyped<IN, IN>;
+export declare function transformLimit<IN>(opt?: TransformLimitOptions): TransformTyped<IN, IN>;

package/dist/stream/transform/transformLimit.js

@@ -1,29 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformLimit = void 0;
-const stream_1 = require("stream");
+exports.transformLimit = exports.TransformLimit = void 0;
+const index_1 = require("../../index");
+const stream_util_1 = require("../stream.util");
+/**
+ * Class only exists to be able to do `instanceof TransformLimit`
+ * and to set sourceReadable+streamDone to it in `_pipeline`.
+ */
+class TransformLimit extends index_1.AbortableTransform {
+}
+exports.TransformLimit = TransformLimit;
 /**
  * 0 or falsy value means "no limit"
  */
-function transformLimit(limit, opt = {}) {
-    const { logger = console } = opt;
-    let index = 0;
+function transformLimit(opt = {}) {
+    const { logger = console, limit, debug } = opt;
+    if (!limit) {
+        // No limit - returning pass-through transform
+        return (0, index_1.transformNoOp)();
+    }
+    let i = 0; // so we start first chunk with 1
     let ended = false;
-    return new stream_1.Transform({
+    return new TransformLimit({
         objectMode: true,
         ...opt,
-        transform(chunk, _encoding, cb) {
-            index++;
-            if (!ended) {
-                cb(null, chunk); // pass through the item
+        transform(chunk, _, cb) {
+            i++;
+            if (i === limit) {
+                ended = true;
+                logger.log(`transformLimit of ${limit} reached`);
+                this.push(chunk);
+                (0, stream_util_1.pipelineClose)('transformLimit', this, opt.sourceReadable || this.sourceReadable, opt.streamDone || this.streamDone, logger);
+                cb(); // after pause
             }
-            else {
-                cb(null); // pass-through empty
+            else if (!ended) {
+                cb(null, chunk);
             }
-            if (limit && index === limit) {
-                ended = true;
-                logger.log(`transformLimit: limit of ${limit} reached`);
-                // this.emit('end') // this makes it "halt" on Node 14 lts
+            else {
+                if (debug)
+                    logger.log(`transformLimit.transform after limit`, i);
+                // If we ever HANG (don't call cb) - Node will do process.exit(0) to us
+                cb(); // ended, don't emit anything
             }
         },
     });