@naturalcycles/nodejs-lib 13.34.4 → 13.34.6

package/dist/stream/transform/transformThrottle.js

@@ -49,7 +49,7 @@ function transformThrottle(opt) {
                 // console.log('pausing now after', {item, count})
                 paused = (0, js_lib_1.pDefer)();
                 if (debug) {
-                    console.log(`${js_lib_1.localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${(0, js_lib_1._ms)(interval * 1000)}, will pause for ${(0, js_lib_1._ms)(interval * 1000 - (Date.now() - start))}`);
+                    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))}`);
                 }
             }
             cb(null, item); // pass the item through
@@ -60,15 +60,20 @@ function transformThrottle(opt) {
         },
     });
     function onInterval(transform) {
-        if (!paused)
-            return;
-        if (debug) {
-            console.log(`${js_lib_1.localTime.now().toPretty()} transformThrottle resumed`);
+        if (paused) {
+            if (debug) {
+                console.log(`${js_lib_1.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)}`);
+            }
         }
         count = 0;
         start = Date.now();
         timeout = setTimeout(() => onInterval(transform), interval * 1000);
-        paused.resolve();
-        paused = undefined;
     }
 }

package/dist/util/exec2.d.ts

@@ -8,7 +8,7 @@ import { AnyObject, AppError, NumberOfMilliseconds } from '@naturalcycles/js-lib
  *
  * Short-running job, no need to print the output, might want to return the output - use Exec.
  *
- * Need to both print and return the output - use SpawnAsync.
+ * Need to both print and return the output - use SpawnAsyncAndReturn.
  *
  * ***
  *
@@ -22,33 +22,13 @@ import { AnyObject, AppError, NumberOfMilliseconds } from '@naturalcycles/js-lib
  * Exec always uses the shell (there's no option to disable it).
  */
 declare class Exec2 {
-    /**
-     * Advanced/async version of Spawn.
-     * Consider simpler `spawn` or `exec` first, which are also sync.
-     *
-     * spawnAsync features:
-     *
-     * 1. Async
-     * 2. Allows to collect the output AND print it while running.
-     * 3. Returns SpawnOutput with stdout, stderr and exitCode.
-     * 4. Allows to not throw on error, but just return SpawnOutput for further inspection.
-     *
-     * Defaults:
-     *
-     * shell: true
-     * printWhileRunning: true
-     * collectOutputWhileRunning: true
-     * throwOnNonZeroCode: true
-     * log: true
-     */
-    spawnAsync(cmd: string, opt?: SpawnAsyncOptions): Promise<SpawnOutput>;
     /**
      * Reasons to use it:
      * - Sync
      * - Need to print output while running
      *
      * Limitations:
-     * - Cannot return stdout/stderr (use exec or spawnAsync for that)
+     * - Cannot return stdout/stderr (use exec, execAsync or spawnAsyncAndReturn for that)
      *
      * Defaults:
      *
@@ -71,7 +51,40 @@ declare class Exec2 {
      * log: false
      */
     exec(cmd: string, opt?: ExecOptions): string;
-    throwOnNonZeroExitCode(o: SpawnOutput): void;
+    /**
+     * Reasons to use it:
+     * - Async
+     * - Need to print output while running
+     *
+     * Limitations:
+     * - Cannot return stdout/stderr (use execAsync or spawnAsyncAndReturn for that)
+     *
+     * Defaults:
+     *
+     * shell: true
+     * log: true
+     */
+    spawnAsync(cmd: string, opt?: SpawnOptions): Promise<void>;
+    /**
+     * Advanced/async version of Spawn.
+     * Consider simpler `spawn` or `exec` first, which are also sync.
+     *
+     * spawnAsyncAndReturn features:
+     *
+     * 1. Async
+     * 2. Allows to collect the output AND print it while running.
+     * 3. Returns SpawnOutput with stdout, stderr and exitCode.
+     * 4. Allows to not throw on error, but just return SpawnOutput for further inspection.
+     *
+     * Defaults:
+     *
+     * shell: true
+     * printWhileRunning: true
+     * collectOutputWhileRunning: true
+     * throwOnNonZeroCode: true
+     * log: true
+     */
+    spawnAsyncAndReturn(cmd: string, opt?: SpawnAsyncOptions): Promise<SpawnOutput>;
     private logStart;
     private logFinish;
 }

package/dist/util/exec2.js

@@ -14,7 +14,7 @@ const colors_1 = require("../colors/colors");
  *
  * Short-running job, no need to print the output, might want to return the output - use Exec.
  *
- * Need to both print and return the output - use SpawnAsync.
+ * Need to both print and return the output - use SpawnAsyncAndReturn.
  *
  * ***
  *
@@ -28,87 +28,13 @@ const colors_1 = require("../colors/colors");
  * Exec always uses the shell (there's no option to disable it).
  */
 class Exec2 {
-    /**
-     * Advanced/async version of Spawn.
-     * Consider simpler `spawn` or `exec` first, which are also sync.
-     *
-     * spawnAsync features:
-     *
-     * 1. Async
-     * 2. Allows to collect the output AND print it while running.
-     * 3. Returns SpawnOutput with stdout, stderr and exitCode.
-     * 4. Allows to not throw on error, but just return SpawnOutput for further inspection.
-     *
-     * Defaults:
-     *
-     * shell: true
-     * printWhileRunning: true
-     * collectOutputWhileRunning: true
-     * throwOnNonZeroCode: true
-     * log: true
-     */
-    async spawnAsync(cmd, opt = {}) {
-        const { shell = true, printWhileRunning = true, collectOutputWhileRunning = true, throwOnNonZeroCode = true, cwd, env, passProcessEnv = true, forceColor = colors_1.hasColors, } = opt;
-        opt.log ??= printWhileRunning; // by default log should be true, as we are printing the output
-        opt.logStart ??= opt.log;
-        opt.logFinish ??= opt.log;
-        const started = Date.now();
-        this.logStart(cmd, opt);
-        let stdout = '';
-        let stderr = '';
-        // if (printWhileRunning) console.log('') // 1-line padding before the output
-        return await new Promise((resolve, reject) => {
-            const p = node_child_process_1.default.spawn(cmd, opt.args || [], {
-                shell,
-                cwd,
-                env: {
-                    ...(passProcessEnv ? process.env : {}),
-                    ...(forceColor ? { FORCE_COLOR: '1' } : {}),
-                    ...env,
-                },
-            });
-            p.stdout.on('data', data => {
-                if (collectOutputWhileRunning) {
-                    stdout += data.toString();
-                    // console.log('stdout:', data.toString())
-                }
-                if (printWhileRunning) {
-                    process.stdout.write(data);
-                    // console.log('stderr:', data.toString())
-                }
-            });
-            p.stderr.on('data', data => {
-                if (collectOutputWhileRunning) {
-                    stderr += data.toString();
-                }
-                if (printWhileRunning) {
-                    process.stderr.write(data);
-                }
-            });
-            p.on('close', code => {
-                // if (printWhileRunning) console.log('') // 1-line padding after the output
-                const isSuccessful = !code;
-                this.logFinish(cmd, opt, started, isSuccessful);
-                const exitCode = code || 0;
-                const o = {
-                    exitCode,
-                    stdout: stdout.trim(),
-                    stderr: stderr.trim(),
-                };
-                if (throwOnNonZeroCode && code) {
-                    return reject(new SpawnError(`spawnAsync exited with code ${code}: ${cmd}`, o));
-                }
-                resolve(o);
-            });
-        });
-    }
     /**
      * Reasons to use it:
      * - Sync
      * - Need to print output while running
      *
      * Limitations:
-     * - Cannot return stdout/stderr (use exec or spawnAsync for that)
+     * - Cannot return stdout/stderr (use exec, execAsync or spawnAsyncAndReturn for that)
      *
      * Defaults:
      *
@@ -122,7 +48,6 @@ class Exec2 {
         opt.logFinish ??= opt.log;
         const started = Date.now();
         this.logStart(cmd, opt);
-        // console.log('') // 1-line padding before the output
         const r = node_child_process_1.default.spawnSync(cmd, opt.args, {
             encoding: 'utf8',
             stdio: 'inherit',
@@ -134,7 +59,6 @@ class Exec2 {
                 ...env,
             },
         });
-        // console.log('') // 1-line padding after the output
         const isSuccessful = !r.error && !r.status;
         this.logFinish(cmd, opt, started, isSuccessful);
         if (r.error) {
@@ -195,10 +119,118 @@ class Exec2 {
             throw new Error(`exec exited with code ${err.status}: ${cmd}`);
         }
     }
-    throwOnNonZeroExitCode(o) {
-        if (o.exitCode) {
-            throw new SpawnError(`spawn exited with code ${o.exitCode}`, o);
-        }
+    /**
+     * Reasons to use it:
+     * - Async
+     * - Need to print output while running
+     *
+     * Limitations:
+     * - Cannot return stdout/stderr (use execAsync or spawnAsyncAndReturn for that)
+     *
+     * Defaults:
+     *
+     * shell: true
+     * log: true
+     */
+    async spawnAsync(cmd, opt = {}) {
+        const { shell = true, cwd, env, passProcessEnv = true, forceColor = colors_1.hasColors } = opt;
+        opt.log ??= true; // by default log should be true, as we are printing the output
+        opt.logStart ??= opt.log;
+        opt.logFinish ??= opt.log;
+        const started = Date.now();
+        this.logStart(cmd, opt);
+        await new Promise((resolve, reject) => {
+            const p = node_child_process_1.default.spawn(cmd, opt.args || [], {
+                shell,
+                cwd,
+                stdio: 'inherit',
+                env: {
+                    ...(passProcessEnv ? process.env : {}),
+                    ...(forceColor ? { FORCE_COLOR: '1' } : {}),
+                    ...env,
+                },
+            });
+            p.on('close', code => {
+                const isSuccessful = !code;
+                this.logFinish(cmd, opt, started, isSuccessful);
+                if (code) {
+                    return reject(new Error(`spawnAsync exited with code ${code}: ${cmd}`));
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Advanced/async version of Spawn.
+     * Consider simpler `spawn` or `exec` first, which are also sync.
+     *
+     * spawnAsyncAndReturn features:
+     *
+     * 1. Async
+     * 2. Allows to collect the output AND print it while running.
+     * 3. Returns SpawnOutput with stdout, stderr and exitCode.
+     * 4. Allows to not throw on error, but just return SpawnOutput for further inspection.
+     *
+     * Defaults:
+     *
+     * shell: true
+     * printWhileRunning: true
+     * collectOutputWhileRunning: true
+     * throwOnNonZeroCode: true
+     * log: true
+     */
+    async spawnAsyncAndReturn(cmd, opt = {}) {
+        const { shell = true, printWhileRunning = true, collectOutputWhileRunning = true, throwOnNonZeroCode = true, cwd, env, passProcessEnv = true, forceColor = colors_1.hasColors, } = opt;
+        opt.log ??= printWhileRunning; // by default log should be true, as we are printing the output
+        opt.logStart ??= opt.log;
+        opt.logFinish ??= opt.log;
+        const started = Date.now();
+        this.logStart(cmd, opt);
+        let stdout = '';
+        let stderr = '';
+        return await new Promise((resolve, reject) => {
+            const p = node_child_process_1.default.spawn(cmd, opt.args || [], {
+                shell,
+                cwd,
+                env: {
+                    ...(passProcessEnv ? process.env : {}),
+                    ...(forceColor ? { FORCE_COLOR: '1' } : {}),
+                    ...env,
+                },
+            });
+            p.stdout.on('data', data => {
+                if (collectOutputWhileRunning) {
+                    stdout += data.toString();
+                    // console.log('stdout:', data.toString())
+                }
+                if (printWhileRunning) {
+                    process.stdout.write(data);
+                    // console.log('stderr:', data.toString())
+                }
+            });
+            p.stderr.on('data', data => {
+                if (collectOutputWhileRunning) {
+                    stderr += data.toString();
+                }
+                if (printWhileRunning) {
+                    process.stderr.write(data);
+                }
+            });
+            p.on('close', code => {
+                const isSuccessful = !code;
+                this.logFinish(cmd, opt, started, isSuccessful);
+                const exitCode = code || 0;
+                const o = {
+                    exitCode,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                };
+                if (throwOnNonZeroCode && code) {
+                    return reject(new SpawnError(`spawnAsyncAndReturn exited with code ${code}: ${cmd}`, o));
+                }
+                resolve(o);
+            });
+        });
     }
     logStart(cmd, opt) {
         if (!opt.logStart)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/nodejs-lib",
-  "version": "13.34.4",
+  "version": "13.34.6",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build",

package/src/stream/transform/transformThrottle.ts

@@ -1,6 +1,7 @@
 import { Transform } from 'node:stream'
 import {
   _ms,
+  _since,
   DeferredPromise,
   localTime,
   NumberOfMilliseconds,
@@ -75,7 +76,7 @@ export function transformThrottle<T>(opt: TransformThrottleOptions): TransformTy
         paused = pDefer()
         if (debug) {
           console.log(
-            `${localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${_ms(interval * 1000)}, will pause for ${_ms(interval * 1000 - (Date.now() - start))}`,
+            `${localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${_since(start)}, will pause for ${_ms(interval * 1000 - (Date.now() - start))}`,
           )
         }
       }
@@ -89,16 +90,23 @@ export function transformThrottle<T>(opt: TransformThrottleOptions): TransformTy
   })
 
   function onInterval(transform: Transform): void {
-    if (!paused) return
+    if (paused) {
+      if (debug) {
+        console.log(`${localTime.now().toPretty()} transformThrottle resumed`)
+      }
 
-    if (debug) {
-      console.log(`${localTime.now().toPretty()} transformThrottle resumed`)
+      paused.resolve()
+      paused = undefined
+    } else {
+      if (debug) {
+        console.log(
+          `${localTime.now().toPretty()} transformThrottle passed ${count} (of max ${throughput}) items in ${_since(start)}`,
+        )
+      }
     }
 
     count = 0
     start = Date.now()
     timeout = setTimeout(() => onInterval(transform), interval * 1000)
-    paused.resolve()
-    paused = undefined
   }
 }

package/src/util/exec2.ts

@@ -17,7 +17,7 @@ import { dimGrey, dimRed, hasColors, white } from '../colors/colors'
  *
  * Short-running job, no need to print the output, might want to return the output - use Exec.
  *
- * Need to both print and return the output - use SpawnAsync.
+ * Need to both print and return the output - use SpawnAsyncAndReturn.
  *
  * ***
  *
@@ -31,101 +31,13 @@ import { dimGrey, dimRed, hasColors, white } from '../colors/colors'
  * Exec always uses the shell (there's no option to disable it).
  */
 class Exec2 {
-  /**
-   * Advanced/async version of Spawn.
-   * Consider simpler `spawn` or `exec` first, which are also sync.
-   *
-   * spawnAsync features:
-   *
-   * 1. Async
-   * 2. Allows to collect the output AND print it while running.
-   * 3. Returns SpawnOutput with stdout, stderr and exitCode.
-   * 4. Allows to not throw on error, but just return SpawnOutput for further inspection.
-   *
-   * Defaults:
-   *
-   * shell: true
-   * printWhileRunning: true
-   * collectOutputWhileRunning: true
-   * throwOnNonZeroCode: true
-   * log: true
-   */
-  async spawnAsync(cmd: string, opt: SpawnAsyncOptions = {}): Promise<SpawnOutput> {
-    const {
-      shell = true,
-      printWhileRunning = true,
-      collectOutputWhileRunning = true,
-      throwOnNonZeroCode = true,
-      cwd,
-      env,
-      passProcessEnv = true,
-      forceColor = hasColors,
-    } = opt
-    opt.log ??= printWhileRunning // by default log should be true, as we are printing the output
-    opt.logStart ??= opt.log
-    opt.logFinish ??= opt.log
-    const started = Date.now()
-    this.logStart(cmd, opt)
-    let stdout = ''
-    let stderr = ''
-
-    // if (printWhileRunning) console.log('') // 1-line padding before the output
-
-    return await new Promise<SpawnOutput>((resolve, reject) => {
-      const p = cp.spawn(cmd, opt.args || [], {
-        shell,
-        cwd,
-        env: {
-          ...(passProcessEnv ? process.env : {}),
-          ...(forceColor ? { FORCE_COLOR: '1' } : {}),
-          ...env,
-        },
-      })
-
-      p.stdout.on('data', data => {
-        if (collectOutputWhileRunning) {
-          stdout += data.toString()
-          // console.log('stdout:', data.toString())
-        }
-        if (printWhileRunning) {
-          process.stdout.write(data)
-          // console.log('stderr:', data.toString())
-        }
-      })
-      p.stderr.on('data', data => {
-        if (collectOutputWhileRunning) {
-          stderr += data.toString()
-        }
-        if (printWhileRunning) {
-          process.stderr.write(data)
-        }
-      })
-
-      p.on('close', code => {
-        // if (printWhileRunning) console.log('') // 1-line padding after the output
-        const isSuccessful = !code
-        this.logFinish(cmd, opt, started, isSuccessful)
-        const exitCode = code || 0
-        const o: SpawnOutput = {
-          exitCode,
-          stdout: stdout.trim(),
-          stderr: stderr.trim(),
-        }
-        if (throwOnNonZeroCode && code) {
-          return reject(new SpawnError(`spawnAsync exited with code ${code}: ${cmd}`, o))
-        }
-        resolve(o)
-      })
-    })
-  }
-
   /**
    * Reasons to use it:
    * - Sync
    * - Need to print output while running
    *
    * Limitations:
-   * - Cannot return stdout/stderr (use exec or spawnAsync for that)
+   * - Cannot return stdout/stderr (use exec, execAsync or spawnAsyncAndReturn for that)
    *
    * Defaults:
    *
@@ -139,7 +51,6 @@ class Exec2 {
     opt.logFinish ??= opt.log
     const started = Date.now()
     this.logStart(cmd, opt)
-    // console.log('') // 1-line padding before the output
 
     const r = cp.spawnSync(cmd, opt.args, {
       encoding: 'utf8',
@@ -153,7 +64,6 @@ class Exec2 {
       },
     })
 
-    // console.log('') // 1-line padding after the output
     const isSuccessful = !r.error && !r.status
     this.logFinish(cmd, opt, started, isSuccessful)
 
@@ -218,10 +128,133 @@ class Exec2 {
     }
   }
 
-  throwOnNonZeroExitCode(o: SpawnOutput): void {
-    if (o.exitCode) {
-      throw new SpawnError(`spawn exited with code ${o.exitCode}`, o)
-    }
+  /**
+   * Reasons to use it:
+   * - Async
+   * - Need to print output while running
+   *
+   * Limitations:
+   * - Cannot return stdout/stderr (use execAsync or spawnAsyncAndReturn for that)
+   *
+   * Defaults:
+   *
+   * shell: true
+   * log: true
+   */
+  async spawnAsync(cmd: string, opt: SpawnOptions = {}): Promise<void> {
+    const { shell = true, cwd, env, passProcessEnv = true, forceColor = hasColors } = opt
+    opt.log ??= true // by default log should be true, as we are printing the output
+    opt.logStart ??= opt.log
+    opt.logFinish ??= opt.log
+    const started = Date.now()
+    this.logStart(cmd, opt)
+
+    await new Promise<void>((resolve, reject) => {
+      const p = cp.spawn(cmd, opt.args || [], {
+        shell,
+        cwd,
+        stdio: 'inherit',
+        env: {
+          ...(passProcessEnv ? process.env : {}),
+          ...(forceColor ? { FORCE_COLOR: '1' } : {}),
+          ...env,
+        },
+      })
+
+      p.on('close', code => {
+        const isSuccessful = !code
+        this.logFinish(cmd, opt, started, isSuccessful)
+        if (code) {
+          return reject(new Error(`spawnAsync exited with code ${code}: ${cmd}`))
+        }
+        resolve()
+      })
+    })
+  }
+
+  /**
+   * Advanced/async version of Spawn.
+   * Consider simpler `spawn` or `exec` first, which are also sync.
+   *
+   * spawnAsyncAndReturn features:
+   *
+   * 1. Async
+   * 2. Allows to collect the output AND print it while running.
+   * 3. Returns SpawnOutput with stdout, stderr and exitCode.
+   * 4. Allows to not throw on error, but just return SpawnOutput for further inspection.
+   *
+   * Defaults:
+   *
+   * shell: true
+   * printWhileRunning: true
+   * collectOutputWhileRunning: true
+   * throwOnNonZeroCode: true
+   * log: true
+   */
+  async spawnAsyncAndReturn(cmd: string, opt: SpawnAsyncOptions = {}): Promise<SpawnOutput> {
+    const {
+      shell = true,
+      printWhileRunning = true,
+      collectOutputWhileRunning = true,
+      throwOnNonZeroCode = true,
+      cwd,
+      env,
+      passProcessEnv = true,
+      forceColor = hasColors,
+    } = opt
+    opt.log ??= printWhileRunning // by default log should be true, as we are printing the output
+    opt.logStart ??= opt.log
+    opt.logFinish ??= opt.log
+    const started = Date.now()
+    this.logStart(cmd, opt)
+    let stdout = ''
+    let stderr = ''
+
+    return await new Promise<SpawnOutput>((resolve, reject) => {
+      const p = cp.spawn(cmd, opt.args || [], {
+        shell,
+        cwd,
+        env: {
+          ...(passProcessEnv ? process.env : {}),
+          ...(forceColor ? { FORCE_COLOR: '1' } : {}),
+          ...env,
+        },
+      })
+
+      p.stdout.on('data', data => {
+        if (collectOutputWhileRunning) {
+          stdout += data.toString()
+          // console.log('stdout:', data.toString())
+        }
+        if (printWhileRunning) {
+          process.stdout.write(data)
+          // console.log('stderr:', data.toString())
+        }
+      })
+      p.stderr.on('data', data => {
+        if (collectOutputWhileRunning) {
+          stderr += data.toString()
+        }
+        if (printWhileRunning) {
+          process.stderr.write(data)
+        }
+      })
+
+      p.on('close', code => {
+        const isSuccessful = !code
+        this.logFinish(cmd, opt, started, isSuccessful)
+        const exitCode = code || 0
+        const o: SpawnOutput = {
+          exitCode,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+        }
+        if (throwOnNonZeroCode && code) {
+          return reject(new SpawnError(`spawnAsyncAndReturn exited with code ${code}: ${cmd}`, o))
+        }
+        resolve(o)
+      })
+    })
   }
 
   private logStart(cmd: string, opt: SpawnOptions | ExecOptions): void {