@naturalcycles/nodejs-lib 12.58.0 → 12.62.0

package/src/util/zip.util.ts

@@ -7,46 +7,52 @@ const inflate = promisify(zlib.inflate.bind(zlib))
 const gzip = promisify(zlib.gzip.bind(zlib))
 const gunzip = promisify(zlib.gunzip.bind(zlib))
 
-// string > zip
+// string > compressed buffer
+
 /**
- * zipBuffer uses `deflate`.
- * It's 9 bytes shorter than gzip.
+ * deflateBuffer uses `deflate`.
+ * It's 9 bytes shorter than `gzip`.
  */
-export async function zipBuffer(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer> {
+export async function deflateBuffer(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer> {
   return await deflate(buf, options)
 }
 
+export async function inflateBuffer(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer> {
+  return await inflate(buf, options)
+}
+
+/**
+ * deflateString uses `deflate`.
+ * It's 9 bytes shorter than `gzip`.
+ */
+export async function deflateString(s: string, options?: ZlibOptions): Promise<Buffer> {
+  return await deflateBuffer(Buffer.from(s), options)
+}
+
+export async function inflateToString(buf: Buffer, options?: ZlibOptions): Promise<string> {
+  return (await inflateBuffer(buf, options)).toString()
+}
+
 /**
  * gzipBuffer uses `gzip`
- * It's 9 bytes longer than deflate.
+ * It's 9 bytes longer than `deflate`.
  */
 export async function gzipBuffer(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer> {
   return await gzip(buf, options)
 }
 
-// zip > buffer
-export async function unzipBuffer(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer> {
-  return await inflate(buf, options)
-}
-
 export async function gunzipBuffer(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer> {
   return await gunzip(buf, options)
 }
 
-// convenience
-export async function zipString(s: string, options?: ZlibOptions): Promise<Buffer> {
-  return await zipBuffer(Buffer.from(s), options)
-}
-
+/**
+ * gzipString uses `gzip`.
+ * It's 9 bytes longer than `deflate`.
+ */
 export async function gzipString(s: string, options?: ZlibOptions): Promise<Buffer> {
   return await gzipBuffer(Buffer.from(s), options)
 }
 
-// convenience
-export async function unzipToString(buf: Buffer, options?: ZlibOptions): Promise<string> {
-  return (await unzipBuffer(buf, options)).toString()
-}
-
 export async function gunzipToString(buf: Buffer, options?: ZlibOptions): Promise<string> {
   return (await gunzipBuffer(buf, options)).toString()
 }

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

@@ -1,17 +0,0 @@
-import { AsyncMapper } from '@naturalcycles/js-lib';
-import { TransformTyped } from '../../stream.model';
-import { TransformMapOptions } from '../transformMap';
-export declare function notNullishPredicate(item: any): boolean;
-/**
- * Like pMap, but for streams.
- * Inspired by `through2`.
- * Main feature is concurrency control (implemented via `through2-concurrent`) and convenient options.
- * Using this allows native stream .pipe() to work and use backpressure.
- *
- * Only works in objectMode (due to through2Concurrent).
- *
- * Concurrency defaults to 16.
- *
- * If an Array is returned by `mapper` - it will be flattened and multiple results will be emitted from it. Tested by Array.isArray().
- */
-export declare function transformMapLegacy<IN = any, OUT = IN>(mapper: AsyncMapper<IN, OUT>, opt?: TransformMapOptions<IN, OUT>): TransformTyped<IN, OUT>;

package/dist/stream/transform/legacy/transformMap.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformMapLegacy = exports.notNullishPredicate = void 0;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const through2Concurrent = require("through2-concurrent");
-const colors_1 = require("../../../colors");
-function notNullishPredicate(item) {
-    return item !== undefined && item !== null;
-}
-exports.notNullishPredicate = notNullishPredicate;
-/**
- * Like pMap, but for streams.
- * Inspired by `through2`.
- * Main feature is concurrency control (implemented via `through2-concurrent`) and convenient options.
- * Using this allows native stream .pipe() to work and use backpressure.
- *
- * Only works in objectMode (due to through2Concurrent).
- *
- * Concurrency defaults to 16.
- *
- * If an Array is returned by `mapper` - it will be flattened and multiple results will be emitted from it. Tested by Array.isArray().
- */
-function transformMapLegacy(mapper, opt = {}) {
-    const { concurrency = 16, predicate = notNullishPredicate, errorMode = js_lib_1.ErrorMode.THROW_IMMEDIATELY, flattenArrayOutput, onError, beforeFinal, metric = 'stream', logger = console, } = opt;
-    let index = -1;
-    let isRejected = false;
-    let errors = 0;
-    const collectedErrors = []; // only used if errorMode == THROW_AGGREGATED
-    return through2Concurrent.obj({
-        maxConcurrency: concurrency,
-        // autoDestroy: true,
-        async final(cb) {
-            // console.log('transformMap final')
-            logErrorStats(logger, true);
-            await beforeFinal?.(); // call beforeFinal if defined
-            if (collectedErrors.length) {
-                // emit Aggregated error
-                cb(new js_lib_1.AggregatedError(collectedErrors));
-            }
-            else {
-                // emit no error
-                cb();
-            }
-        },
-    }, async function transformMapFn(chunk, _encoding, cb) {
-        index++;
-        // console.log({chunk, _encoding})
-        // Stop processing if THROW_IMMEDIATELY mode is used
-        if (isRejected && errorMode === js_lib_1.ErrorMode.THROW_IMMEDIATELY)
-            return cb();
-        try {
-            const currentIndex = index; // because we need to pass it to 2 functions - mapper and predicate. Refers to INPUT index (since it may return multiple outputs)
-            const res = await mapper(chunk, currentIndex);
-            const passedResults = await (0, js_lib_1.pFilter)(flattenArrayOutput && Array.isArray(res) ? res : [res], async (r) => await predicate(r, currentIndex));
-            if (passedResults.length === 0) {
-                cb(); // 0 results
-            }
-            else {
-                passedResults.forEach(r => {
-                    this.push(r);
-                    // cb(null, r)
-                });
-                cb(); // done processing
-            }
-        }
-        catch (err) {
-            logger.error(err);
-            errors++;
-            logErrorStats(logger);
-            if (onError) {
-                try {
-                    onError(err, chunk);
-                }
-                catch { }
-            }
-            if (errorMode === js_lib_1.ErrorMode.THROW_IMMEDIATELY) {
-                isRejected = true;
-                // Emit error immediately
-                return cb(err);
-            }
-            if (errorMode === js_lib_1.ErrorMode.THROW_AGGREGATED) {
-                collectedErrors.push(err);
-            }
-            // Tell input stream that we're done processing, but emit nothing to output - not error nor result
-            cb();
-        }
-    });
-    function logErrorStats(logger, final = false) {
-        if (!errors)
-            return;
-        logger.log(`${metric} ${final ? 'final ' : ''}errors: ${(0, colors_1.yellow)(errors)}`);
-    }
-}
-exports.transformMapLegacy = transformMapLegacy;

package/src/stream/transform/legacy/transformMap.ts

@@ -1,133 +0,0 @@
-import { Transform } from 'stream'
-import {
-  AggregatedError,
-  AsyncMapper,
-  CommonLogger,
-  ErrorMode,
-  pFilter,
-} from '@naturalcycles/js-lib'
-import through2Concurrent = require('through2-concurrent')
-import { yellow } from '../../../colors'
-import { TransformTyped } from '../../stream.model'
-import { TransformMapOptions } from '../transformMap'
-
-export function notNullishPredicate(item: any): boolean {
-  return item !== undefined && item !== null
-}
-
-/**
- * Like pMap, but for streams.
- * Inspired by `through2`.
- * Main feature is concurrency control (implemented via `through2-concurrent`) and convenient options.
- * Using this allows native stream .pipe() to work and use backpressure.
- *
- * Only works in objectMode (due to through2Concurrent).
- *
- * Concurrency defaults to 16.
- *
- * If an Array is returned by `mapper` - it will be flattened and multiple results will be emitted from it. Tested by Array.isArray().
- */
-export function transformMapLegacy<IN = any, OUT = IN>(
-  mapper: AsyncMapper<IN, OUT>,
-  opt: TransformMapOptions<IN, OUT> = {},
-): TransformTyped<IN, OUT> {
-  const {
-    concurrency = 16,
-    predicate = notNullishPredicate,
-    errorMode = ErrorMode.THROW_IMMEDIATELY,
-    flattenArrayOutput,
-    onError,
-    beforeFinal,
-    metric = 'stream',
-    logger = console,
-  } = opt
-
-  let index = -1
-  let isRejected = false
-  let errors = 0
-  const collectedErrors: Error[] = [] // only used if errorMode == THROW_AGGREGATED
-
-  return through2Concurrent.obj(
-    {
-      maxConcurrency: concurrency,
-      // autoDestroy: true,
-      async final(cb) {
-        // console.log('transformMap final')
-
-        logErrorStats(logger, true)
-
-        await beforeFinal?.() // call beforeFinal if defined
-
-        if (collectedErrors.length) {
-          // emit Aggregated error
-          cb(new AggregatedError(collectedErrors))
-        } else {
-          // emit no error
-          cb()
-        }
-      },
-    },
-    async function transformMapFn(
-      this: Transform,
-      chunk: IN,
-      _encoding: any,
-      cb: (...args: any[]) => any,
-    ) {
-      index++
-      // console.log({chunk, _encoding})
-
-      // Stop processing if THROW_IMMEDIATELY mode is used
-      if (isRejected && errorMode === ErrorMode.THROW_IMMEDIATELY) return cb()
-
-      try {
-        const currentIndex = index // because we need to pass it to 2 functions - mapper and predicate. Refers to INPUT index (since it may return multiple outputs)
-        const res = await mapper(chunk, currentIndex)
-        const passedResults = await pFilter(
-          flattenArrayOutput && Array.isArray(res) ? res : [res],
-          async r => await predicate(r, currentIndex),
-        )
-
-        if (passedResults.length === 0) {
-          cb() // 0 results
-        } else {
-          passedResults.forEach(r => {
-            this.push(r)
-            // cb(null, r)
-          })
-          cb() // done processing
-        }
-      } catch (err) {
-        logger.error(err)
-
-        errors++
-
-        logErrorStats(logger)
-
-        if (onError) {
-          try {
-            onError(err, chunk)
-          } catch {}
-        }
-
-        if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
-          isRejected = true
-          // Emit error immediately
-          return cb(err)
-        }
-
-        if (errorMode === ErrorMode.THROW_AGGREGATED) {
-          collectedErrors.push(err as Error)
-        }
-
-        // Tell input stream that we're done processing, but emit nothing to output - not error nor result
-        cb()
-      }
-    },
-  )
-
-  function logErrorStats(logger: CommonLogger, final = false): void {
-    if (!errors) return
-
-    logger.log(`${metric} ${final ? 'final ' : ''}errors: ${yellow(errors)}`)
-  }
-}