@naturalcycles/nodejs-lib 13.45.3 → 14.0.0

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

@@ -1,6 +1,6 @@
 import type { AsyncPredicate, Predicate } from '@naturalcycles/js-lib';
-import type { TransformOptions, TransformTyped } from '../stream.model';
-import type { TransformMapOptions } from './transformMap';
+import type { TransformOptions, TransformTyped } from '../stream.model.js';
+import type { TransformMapOptions } from './transformMap.js';
 /**
  * Just a convenience wrapper around `transformMap` that has built-in predicate filtering support.
  */

package/dist/stream/transform/transformFilter.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFilter = transformFilter;
-exports.transformFilterSync = transformFilterSync;
-const node_stream_1 = require("node:stream");
-const transformMap_1 = require("./transformMap");
+import { Transform } from 'node:stream';
+import { transformMap } from './transformMap.js';
 /**
  * Just a convenience wrapper around `transformMap` that has built-in predicate filtering support.
  */
-function transformFilter(predicate, opt = {}) {
-    return (0, transformMap_1.transformMap)(v => v, {
+export function transformFilter(predicate, opt = {}) {
+    return transformMap(v => v, {
         predicate,
         ...opt,
     });
@@ -16,9 +12,9 @@ function transformFilter(predicate, opt = {}) {
 /**
  * Sync version of `transformFilter`
  */
-function transformFilterSync(predicate, opt = {}) {
+export function transformFilterSync(predicate, opt = {}) {
     let index = 0;
-    return new node_stream_1.Transform({
+    return new Transform({
         objectMode: true,
         ...opt,
         transform(chunk, _, cb) {

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

@@ -1,7 +1,7 @@
 import type { Readable } from 'node:stream';
 import type { CommonLogger } from '@naturalcycles/js-lib';
-import { AbortableTransform } from '../../index';
-import type { TransformOptions, TransformTyped } from '../stream.model';
+import { AbortableTransform } from '../../index.js';
+import type { TransformOptions, TransformTyped } from '../stream.model.js';
 export interface TransformLimitOptions extends TransformOptions {
     /**
      * Nullish value (e.g 0 or undefined) would mean "no limit"

package/dist/stream/transform/transformLimit.js

@@ -1,21 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransformLimit = void 0;
-exports.transformLimit = transformLimit;
-const index_1 = require("../../index");
-const stream_util_1 = require("../stream.util");
+import { AbortableTransform, transformNoOp } from '../../index.js';
+import { pipelineClose } from '../stream.util.js';
 /**
  * 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 {
+export class TransformLimit extends AbortableTransform {
 }
-exports.TransformLimit = TransformLimit;
-function transformLimit(opt) {
+export function transformLimit(opt) {
     const { logger = console, limit, debug } = opt;
     if (!limit) {
         // No limit - returning pass-through transform
-        return (0, index_1.transformNoOp)();
+        return transformNoOp();
     }
     let i = 0; // so we start first chunk with 1
     let ended = false;
@@ -28,7 +23,7 @@ function transformLimit(opt) {
                 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);
+                pipelineClose('transformLimit', this, opt.sourceReadable || this.sourceReadable, opt.streamDone || this.streamDone, logger);
                 cb(); // after pause
             }
             else if (!ended) {

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

@@ -1,5 +1,5 @@
-import type { ProgressLoggerCfg } from '../progressLogger';
-import type { TransformOptions, TransformTyped } from '../stream.model';
+import type { ProgressLoggerCfg } from '../progressLogger.js';
+import type { TransformOptions, TransformTyped } from '../stream.model.js';
 export interface TransformLogProgressOptions<IN = any> extends ProgressLoggerCfg<IN>, TransformOptions {
 }
 /**

package/dist/stream/transform/transformLogProgress.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformLogProgress = transformLogProgress;
-const node_stream_1 = require("node:stream");
-const progressLogger_1 = require("../progressLogger");
+import { Transform } from 'node:stream';
+import { progressLogger } from '../progressLogger.js';
 /**
  * Pass-through transform that optionally logs progress.
  */
-function transformLogProgress(opt = {}) {
-    const progress = (0, progressLogger_1.progressLogger)(opt);
-    return new node_stream_1.Transform({
+export function transformLogProgress(opt = {}) {
+    const progress = progressLogger(opt);
+    return new Transform({
         objectMode: true,
         ...opt,
         transform(chunk, _, cb) {

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

@@ -1,6 +1,6 @@
 import type { AbortableAsyncMapper, AsyncPredicate, CommonLogger, Promisable, StringMap, UnixTimestampMillis } from '@naturalcycles/js-lib';
 import { END, ErrorMode, SKIP } from '@naturalcycles/js-lib';
-import type { TransformTyped } from '../stream.model';
+import type { TransformTyped } from '../stream.model.js';
 export interface TransformMapOptions<IN = any, OUT = IN> {
     /**
      * Set true to support "multiMap" - possibility to return [] and emit 1 result for each item in the array.

package/dist/stream/transform/transformMap.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformMap = transformMap;
-exports.transformMapStatsSummary = transformMapStatsSummary;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const through2Concurrent = require("through2-concurrent");
-const colors_1 = require("../../colors/colors");
-const stream_util_1 = require("../stream.util");
+import { _anyToError, _hc, _since, _stringify, END, ErrorMode, pFilter, SKIP, } from '@naturalcycles/js-lib';
+import through2Concurrent from 'through2-concurrent';
+import { yellow } from '../../colors/colors.js';
+import { pipelineClose } from '../stream.util.js';
 // doesn't work, cause here we don't construct our Transform instance ourselves
 // export class TransformMap extends AbortableTransform {}
 /**
@@ -20,9 +16,9 @@ const stream_util_1 = require("../stream.util");
  *
  * If an Array is returned by `mapper` - it will be flattened and multiple results will be emitted from it. Tested by Array.isArray().
  */
-function transformMap(mapper, opt = {}) {
+export function transformMap(mapper, opt = {}) {
     const { concurrency = 16, predicate, // we now default to "no predicate" (meaning pass-everything)
-    errorMode = js_lib_1.ErrorMode.THROW_IMMEDIATELY, flattenArrayOutput, onError, onDone, metric = 'stream', logger = console, } = opt;
+    errorMode = ErrorMode.THROW_IMMEDIATELY, flattenArrayOutput, onError, onDone, metric = 'stream', logger = console, } = opt;
     const started = Date.now();
     let index = -1;
     let countOut = 0;
@@ -76,18 +72,18 @@ function transformMap(mapper, opt = {}) {
         const currentIndex = ++index;
         try {
             const res = await mapper(chunk, currentIndex);
-            const passedResults = await (0, js_lib_1.pFilter)(flattenArrayOutput && Array.isArray(res) ? res : [res], async (r) => {
-                if (r === js_lib_1.END) {
+            const passedResults = await pFilter(flattenArrayOutput && Array.isArray(res) ? res : [res], async (r) => {
+                if (r === END) {
                     isSettled = true; // will be checked later
                     return false;
                 }
-                return r !== js_lib_1.SKIP && (!predicate || (await predicate(r, currentIndex)));
+                return r !== SKIP && (!predicate || (await predicate(r, currentIndex)));
             });
             countOut += passedResults.length;
             passedResults.forEach(r => this.push(r));
             if (isSettled) {
                 logger.log(`transformMap END received at index ${currentIndex}`);
-                (0, stream_util_1.pipelineClose)('transformMap', this, this.sourceReadable, this.streamDone, logger);
+                pipelineClose('transformMap', this, this.sourceReadable, this.streamDone, logger);
             }
             cb(); // done processing
         }
@@ -97,11 +93,11 @@ function transformMap(mapper, opt = {}) {
             logErrorStats();
             if (onError) {
                 try {
-                    onError((0, js_lib_1._anyToError)(err), chunk);
+                    onError(_anyToError(err), chunk);
                 }
                 catch { }
             }
-            if (errorMode === js_lib_1.ErrorMode.THROW_IMMEDIATELY) {
+            if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
                 isSettled = true;
                 try {
                     await onDone?.({
@@ -118,7 +114,7 @@ function transformMap(mapper, opt = {}) {
                 }
                 return cb(err); // Emit error immediately
             }
-            if (errorMode === js_lib_1.ErrorMode.THROW_AGGREGATED) {
+            if (errorMode === ErrorMode.THROW_AGGREGATED) {
                 collectedErrors.push(err);
             }
             // Tell input stream that we're done processing, but emit nothing to output - not error nor result
@@ -128,21 +124,21 @@ function transformMap(mapper, opt = {}) {
     function logErrorStats(final = false) {
         if (!errors)
             return;
-        logger.log(`${metric} ${final ? 'final ' : ''}errors: ${(0, colors_1.yellow)(errors)}`);
+        logger.log(`${metric} ${final ? 'final ' : ''}errors: ${yellow(errors)}`);
     }
 }
 /**
  * Renders TransformMapStatsSummary into a friendly string,
  * to be used e.g in Github Actions summary or Slack.
  */
-function transformMapStatsSummary(summary) {
+export function transformMapStatsSummary(summary) {
     const { countIn, countOut, countErrors, started, name = 'Transform', extra = {} } = summary;
     return [
         `### ${name} summary\n`,
-        `${(0, js_lib_1._since)(started)} spent`,
-        `${(0, js_lib_1._hc)(countIn)} / ${(0, js_lib_1._hc)(countOut)} row(s) in / out`,
+        `${_since(started)} spent`,
+        `${_hc(countIn)} / ${_hc(countOut)} row(s) in / out`,
         countErrors ? `${countErrors} error(s)` : '',
-        ...Object.entries(extra).map(([k, v]) => `${k}: ${(0, js_lib_1._stringify)(v)}`),
+        ...Object.entries(extra).map(([k, v]) => `${k}: ${_stringify(v)}`),
     ]
         .filter(Boolean)
         .join('\n');

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

@@ -1,6 +1,6 @@
 import type { CommonLogger, Mapper } from '@naturalcycles/js-lib';
 import { ErrorMode } from '@naturalcycles/js-lib';
-import type { TransformTyped } from '../stream.model';
+import type { TransformTyped } from '../stream.model.js';
 export interface TransformMapSimpleOptions {
     /**
      * Only supports THROW_IMMEDIATELY (default) and SUPPRESS.

package/dist/stream/transform/transformMapSimple.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformMapSimple = transformMapSimple;
-const node_stream_1 = require("node:stream");
-const js_lib_1 = require("@naturalcycles/js-lib");
+import { Transform } from 'node:stream';
+import { ErrorMode } from '@naturalcycles/js-lib';
 /**
  * Simplest version of `transformMap`.
  * errorMode: IMMEDIATE
@@ -12,10 +9,10 @@ const js_lib_1 = require("@naturalcycles/js-lib");
  * Sync (not async) version of transformMap.
  * Supposedly faster, for cases when async is not needed.
  */
-function transformMapSimple(mapper, opt = {}) {
+export function transformMapSimple(mapper, opt = {}) {
     let index = -1;
-    const { errorMode = js_lib_1.ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
-    return new node_stream_1.Transform({
+    const { errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
+    return new Transform({
         objectMode: true,
         transform(chunk, _, cb) {
             try {
@@ -23,7 +20,7 @@ function transformMapSimple(mapper, opt = {}) {
             }
             catch (err) {
                 logger.error(err);
-                if (errorMode === js_lib_1.ErrorMode.SUPPRESS) {
+                if (errorMode === ErrorMode.SUPPRESS) {
                     cb(); // suppress the error
                 }
                 else {

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

@@ -1,8 +1,8 @@
 import type { CommonLogger, Mapper, Predicate } from '@naturalcycles/js-lib';
 import { END, ErrorMode, SKIP } from '@naturalcycles/js-lib';
-import { AbortableTransform } from '../pipeline/pipeline';
-import type { TransformTyped } from '../stream.model';
-import type { TransformMapStats } from './transformMap';
+import { AbortableTransform } from '../pipeline/pipeline.js';
+import type { TransformTyped } from '../stream.model.js';
+import type { TransformMapStats } from './transformMap.js';
 export interface TransformMapSyncOptions<IN = any, OUT = IN> {
     /**
      * @default true

package/dist/stream/transform/transformMapSync.js

@@ -1,21 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransformMapSync = void 0;
-exports.transformMapSync = transformMapSync;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const colors_1 = require("../../colors/colors");
-const pipeline_1 = require("../pipeline/pipeline");
-const stream_util_1 = require("../stream.util");
-class TransformMapSync extends pipeline_1.AbortableTransform {
+import { _anyToError, END, ErrorMode, SKIP } from '@naturalcycles/js-lib';
+import { yellow } from '../../colors/colors.js';
+import { AbortableTransform } from '../pipeline/pipeline.js';
+import { pipelineClose } from '../stream.util.js';
+export class TransformMapSync extends AbortableTransform {
 }
-exports.TransformMapSync = TransformMapSync;
 /**
  * Sync (not async) version of transformMap.
  * Supposedly faster, for cases when async is not needed.
  */
-function transformMapSync(mapper, opt = {}) {
+export function transformMapSync(mapper, opt = {}) {
     const { predicate, // defaults to "no predicate" (pass everything)
-    errorMode = js_lib_1.ErrorMode.THROW_IMMEDIATELY, flattenArrayOutput = false, onError, onDone, metric = 'stream', objectMode = true, logger = console, } = opt;
+    errorMode = ErrorMode.THROW_IMMEDIATELY, flattenArrayOutput = false, onError, onDone, metric = 'stream', objectMode = true, logger = console, } = opt;
     const started = Date.now();
     let index = -1;
     let countOut = 0;
@@ -34,17 +29,17 @@ function transformMapSync(mapper, opt = {}) {
                 // map and pass through
                 const v = mapper(chunk, currentIndex);
                 const passedResults = (flattenArrayOutput && Array.isArray(v) ? v : [v]).filter(r => {
-                    if (r === js_lib_1.END) {
+                    if (r === END) {
                         isSettled = true; // will be checked later
                         return false;
                     }
-                    return r !== js_lib_1.SKIP && (!predicate || predicate(r, currentIndex));
+                    return r !== SKIP && (!predicate || predicate(r, currentIndex));
                 });
                 countOut += passedResults.length;
                 passedResults.forEach(r => this.push(r));
                 if (isSettled) {
                     logger.log(`transformMapSync END received at index ${currentIndex}`);
-                    (0, stream_util_1.pipelineClose)('transformMapSync', this, this.sourceReadable, this.streamDone, logger);
+                    pipelineClose('transformMapSync', this, this.sourceReadable, this.streamDone, logger);
                 }
                 cb(); // done processing
             }
@@ -54,11 +49,11 @@ function transformMapSync(mapper, opt = {}) {
                 logErrorStats();
                 if (onError) {
                     try {
-                        onError((0, js_lib_1._anyToError)(err), chunk);
+                        onError(_anyToError(err), chunk);
                     }
                     catch { }
                 }
-                if (errorMode === js_lib_1.ErrorMode.THROW_IMMEDIATELY) {
+                if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
                     isSettled = true;
                     try {
                         onDone?.({
@@ -76,7 +71,7 @@ function transformMapSync(mapper, opt = {}) {
                     // Emit error immediately
                     return cb(err);
                 }
-                if (errorMode === js_lib_1.ErrorMode.THROW_AGGREGATED) {
+                if (errorMode === ErrorMode.THROW_AGGREGATED) {
                     collectedErrors.push(err);
                 }
                 cb();
@@ -124,6 +119,6 @@ function transformMapSync(mapper, opt = {}) {
     function logErrorStats(final = false) {
         if (!errors)
             return;
-        logger.log(`${metric} ${final ? 'final ' : ''}errors: ${(0, colors_1.yellow)(errors)}`);
+        logger.log(`${metric} ${final ? 'final ' : ''}errors: ${yellow(errors)}`);
     }
 }

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

@@ -1,4 +1,4 @@
-import type { TransformTyped } from '../stream.model';
+import type { TransformTyped } from '../stream.model.js';
 /**
  * Transform that does nothing (pass the data through).
  * Can be used e.g to convert "not-valid" stream (e.g one that `transformMap` is producing)

package/dist/stream/transform/transformNoOp.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformNoOp = transformNoOp;
-const node_stream_1 = require("node:stream");
+import { Transform } from 'node:stream';
 /**
  * Transform that does nothing (pass the data through).
  * Can be used e.g to convert "not-valid" stream (e.g one that `transformMap` is producing)
  * into a "valid" stream (that implements async-iteration interface).
  */
-function transformNoOp() {
-    return new node_stream_1.Transform({
+export function transformNoOp() {
+    return new Transform({
         objectMode: true,
         transform(chunk, _, cb) {
             cb(null, chunk);

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

@@ -1,4 +1,4 @@
-import type { TransformOptions, TransformTyped } from '../stream.model';
+import type { TransformOptions, TransformTyped } from '../stream.model.js';
 export interface TransformOffsetOptions extends TransformOptions {
     /**
      * How many items to skip (offset) in the stream.

package/dist/stream/transform/transformOffset.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformOffset = transformOffset;
-const node_stream_1 = require("node:stream");
-const index_1 = require("../../index");
-function transformOffset(opt) {
+import { Transform } from 'node:stream';
+import { transformNoOp } from '../../index.js';
+export function transformOffset(opt) {
     const { offset } = opt;
     if (!offset) {
         // No offset - returning pass-through transform
-        return (0, index_1.transformNoOp)();
+        return transformNoOp();
     }
     let i = 0; // so we start first chunk with 1
-    return new node_stream_1.Transform({
+    return new Transform({
         objectMode: true,
         ...opt,
         transform(chunk, _, cb) {

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

@@ -1,4 +1,4 @@
-import type { TransformTyped } from '../stream.model';
+import type { TransformTyped } from '../stream.model.js';
 /**
  * Transforms input Buffer/string stream into Buffer chunks (objectMode: true) split by newLine.
  *

package/dist/stream/transform/transformSplit.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformSplitOnNewline = transformSplitOnNewline;
-exports.transformSplit = transformSplit;
-const node_stream_1 = require("node:stream");
+import { Transform } from 'node:stream';
 // The code below is carefully adopted from: https://github.com/max-mapper/binary-split
 /**
  * Transforms input Buffer/string stream into Buffer chunks (objectMode: true) split by newLine.
@@ -12,9 +8,9 @@ const node_stream_1 = require("node:stream");
  * Same as binarySplit, but optimized (hard-coded) to split on NEWLINE (aka `\n`).
  * (+5-10% _pipeline speedup measured, compared to generic `binarySplit` on variable length delimiter)
  */
-function transformSplitOnNewline() {
+export function transformSplitOnNewline() {
     let buffered;
-    return new node_stream_1.Transform({
+    return new Transform({
         readableObjectMode: true,
         writableHighWaterMark: 64 * 1024,
         transform(buf, _enc, done) {
@@ -55,10 +51,10 @@ function transformSplitOnNewline() {
  * Please use slightly more optimized `transformSplitOnNewline` for NDJSON file parsing.
  * (+5-10% _pipeline speedup measured!)
  */
-function transformSplit(separator = '\n') {
+export function transformSplit(separator = '\n') {
     const matcher = Buffer.from(separator);
     let buffered;
-    return new node_stream_1.Transform({
+    return new Transform({
         readableObjectMode: true,
         writableHighWaterMark: 64 * 1024,
         transform(buf, _enc, done) {

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

@@ -1,5 +1,5 @@
 import type { AsyncMapper, CommonLogger } from '@naturalcycles/js-lib';
-import type { TransformOptions, TransformTyped } from '../stream.model';
+import type { TransformOptions, TransformTyped } from '../stream.model.js';
 export interface TransformTapOptions extends TransformOptions {
     logger?: CommonLogger;
 }

package/dist/stream/transform/transformTap.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformTap = transformTap;
-const node_stream_1 = require("node:stream");
+import { Transform } from 'node:stream';
 /**
  * Similar to RxJS `tap` - allows to run a function for each stream item, without affecting the result.
  * Item is passed through to the output.
  *
  * Can also act as a counter, since `index` is passed to `fn`
  */
-function transformTap(fn, opt = {}) {
+export function transformTap(fn, opt = {}) {
     const { logger = console } = opt;
     let index = -1;
-    return new node_stream_1.Transform({
+    return new Transform({
         objectMode: true,
         ...opt,
         async transform(chunk, _, cb) {

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

@@ -1,4 +1,4 @@
-import type { TransformTyped } from '../stream.model';
+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".

package/dist/stream/transform/transformTee.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformTee = transformTee;
-const node_stream_1 = require("node:stream");
-const pipeline_1 = require("../pipeline/pipeline");
-const readableCreate_1 = require("../readable/readableCreate");
+import { Transform } from 'node:stream';
+import { _pipeline } from '../pipeline/pipeline.js';
+import { readableCreate } from '../readable/readableCreate.js';
 /**
  * Allows to "tee"/"fork" away from the "main pipeline" into the "secondary pipeline".
  *
@@ -13,10 +10,10 @@ const readableCreate_1 = require("../readable/readableCreate");
  *
  * @experimental
  */
-function transformTee(streams) {
-    const readable = (0, readableCreate_1.readableCreate)();
-    const secondPipelinePromise = (0, pipeline_1._pipeline)([readable, ...streams]);
-    return new node_stream_1.Transform({
+export function transformTee(streams) {
+    const readable = readableCreate();
+    const secondPipelinePromise = _pipeline([readable, ...streams]);
+    return new Transform({
         objectMode: true,
         transform(chunk, _, cb) {
             // pass to the "secondary" pipeline

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

@@ -1,5 +1,5 @@
 import type { NumberOfSeconds, PositiveInteger } from '@naturalcycles/js-lib';
-import type { TransformTyped } from '../stream.model';
+import type { TransformTyped } from '../stream.model.js';
 export interface TransformThrottleOptions {
     /**
      * How many items to allow per `interval` of seconds.

package/dist/stream/transform/transformThrottle.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformThrottle = transformThrottle;
-const node_stream_1 = require("node:stream");
-const js_lib_1 = require("@naturalcycles/js-lib");
+import { Transform } from 'node:stream';
+import { _ms, _since, localTime, pDefer } from '@naturalcycles/js-lib';
 /**
  * Allows to throttle the throughput of the stream.
  * For example, when you have an API with rate limit of 5000 requests per minute,
@@ -20,13 +17,13 @@ const js_lib_1 = require("@naturalcycles/js-lib");
  *
  * @experimental
  */
-function transformThrottle(opt) {
+export function transformThrottle(opt) {
     const { throughput, interval, debug } = opt;
     let count = 0;
     let start;
     let paused;
     let timeout;
-    return new node_stream_1.Transform({
+    return new Transform({
         objectMode: true,
         async transform(item, _, cb) {
             // console.log('incoming', item, { paused: !!paused, count })
@@ -34,7 +31,7 @@ function transformThrottle(opt) {
                 start = Date.now();
                 timeout = setTimeout(() => onInterval(this), interval * 1000);
                 if (debug) {
-                    console.log(`${js_lib_1.localTime.now().toPretty()} transformThrottle started with`, {
+                    console.log(`${localTime.now().toPretty()} transformThrottle started with`, {
                         throughput,
                         interval,
                         rps: Math.round(throughput / interval),
@@ -47,9 +44,9 @@ function transformThrottle(opt) {
             }
             if (++count >= throughput) {
                 // console.log('pausing now after', {item, count})
-                paused = (0, js_lib_1.pDefer)();
+                paused = pDefer();
                 if (debug) {
-                    console.log(`${js_lib_1.localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${(0, js_lib_1._since)(start)}, will pause for ${(0, js_lib_1._ms)(interval * 1000 - (Date.now() - start))}`);
+                    console.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
@@ -62,14 +59,14 @@ function transformThrottle(opt) {
     function onInterval(transform) {
         if (paused) {
             if (debug) {
-                console.log(`${js_lib_1.localTime.now().toPretty()} transformThrottle resumed`);
+                console.log(`${localTime.now().toPretty()} transformThrottle resumed`);
             }
             paused.resolve();
             paused = undefined;
         }
         else {
             if (debug) {
-                console.log(`${js_lib_1.localTime.now().toPretty()} transformThrottle passed ${count} (of max ${throughput}) items in ${(0, js_lib_1._since)(start)}`);
+                console.log(`${localTime.now().toPretty()} transformThrottle passed ${count} (of max ${throughput}) items in ${_since(start)}`);
             }
         }
         count = 0;

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

@@ -1,4 +1,4 @@
-import type { TransformOptions, TransformTyped } from '../stream.model';
+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.
  */

package/dist/stream/transform/transformToArray.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformToArray = transformToArray;
-const node_stream_1 = require("node:stream");
+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.
  */
-function transformToArray(opt = {}) {
+export function transformToArray(opt = {}) {
     const res = [];
-    return new node_stream_1.Transform({
+    return new Transform({
         objectMode: true,
         ...opt,
         transform(chunk, _, cb) {

package/dist/stream/transform/worker/baseWorkerClass.d.ts

@@ -1,4 +1,4 @@
-import type { BaseWorkerData } from './transformMultiThreaded.model';
+import type { BaseWorkerData } from './transformMultiThreaded.model.js';
 export interface WorkerClassInterface<IN, OUT, WORKER_DATA extends BaseWorkerData = BaseWorkerData> {
     WorkerClass: BaseWorkerClass<IN, OUT, WORKER_DATA>;
 }