@vbarbarosh/node-helpers 3.34.2 → 3.36.0

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "3.34.2",
+    "version": "3.36.0",
     "description": "A set of helpers for JavaScript/Node.js",
     "files": [
         "src"

package/src/countdown.js

@@ -0,0 +1,51 @@
+/**
+ * Wait for a promise/value to be settled. Meanwhile, call `tick` function every `tick_ms` milliseconds.
+ * After `timeout` seconds, reject with 'Timeout' error.
+ *
+ * @see user_friendly_status
+ * @see progress
+ */
+function countdown(ctx)
+{
+    let done = false;
+    let timer = null;
+    return new Promise(function (resolve, reject) {
+        ctx.value = Promise.resolve(ctx.value);
+        ctx.timeout = ctx.timeout || 0;
+        ctx.time_now = new Date();
+        ctx.time_begin = new Date();
+        ctx.time_end = Date.now() + ctx.timeout;
+        ctx.tick_ms = ctx.tick_ms || 1000;
+        ctx.tick = ctx.tick || function () {};
+        ctx.resolve = function (value) {
+            if (done) {
+                throw new Error('Already settled');
+            }
+            done = true;
+            clearInterval(timer);
+            resolve(value);
+        };
+        ctx.reject = function (error) {
+            if (done) {
+                throw new Error('Already settled');
+            }
+            done = true;
+            clearInterval(timer);
+            reject(error);
+        };
+        timer = setInterval(tick, ctx.tick_ms);
+        ctx.value.then(ctx.resolve, ctx.reject);
+        tick();
+        function tick() {
+            ctx.time_now = Date.now();
+            ctx.time_elapsed = ctx.time_now - ctx.time_begin;
+            ctx.time_remained = Math.max(0, ctx.time_end - ctx.time_now);
+            ctx.tick(ctx);
+            if (!ctx.time_remained) {
+                ctx.reject(new Error('Timeout'));
+            }
+        }
+    });
+}
+
+module.exports = countdown;

package/src/shell_curl_progress.js

@@ -0,0 +1,35 @@
+const Promise = require('bluebird');
+const child_process = require('child_process');
+const stream = require('stream');
+const stream_curl_progress = require('./stream_curl_progress');
+const stream_each = require('./stream_each');
+
+async function shell_curl_progress(args, {options, user_friendly_status})
+{
+    // $ man curl
+    // > If you want a progress meter for HTTP POST or PUT requests,
+    // > you need to redirect the response output to a file, using
+    // > shell redirect (>), -o, --output or similar.
+
+    const tmp = ['--progress-meter'];
+    if (!args.includes('-o')) {
+        tmp.push('-o', '/dev/null');
+    }
+    const proc = child_process.spawn(args[0], args.slice(1).concat(tmp), {...options, stdio: ['inherit', 'inherit', 'pipe']});
+
+    const promises = [];
+    promises.push(new Promise(function (resolve, reject) {
+        proc.once('error', reject);
+        proc.once('exit', code => code ? reject(new Error(`Process terminated with code ${code}`)) : resolve());
+    }));
+    promises.push(stream.promises.pipeline(proc.stderr, stream_curl_progress(), stream_each(progress_fn)));
+
+    await Promise.all(promises);
+
+    function progress_fn(v) {
+        const speed = v.speed === '0' ? '~' : `${v.speed}/s`;
+        user_friendly_status(`${v.perc}% | ${v.done} of ${v.total} at ${speed} ETA ${v.eta} duration=${v.duration}`);
+    }
+}
+
+module.exports = shell_curl_progress;

package/src/shell_ytdlp_progress.js

@@ -0,0 +1,21 @@
+const child_process = require('child_process');
+const stream = require('stream');
+const stream_each = require('./stream_each');
+const stream_ytdlp_progress = require('./stream_ytdlp_progress');
+
+async function shell_ytdlp_progress(args, {progress_fn, ...options})
+{
+    const proc = child_process.spawn('yt-dlp', ['--progress', ...args], {...options, stdio: 'pipe'});
+
+    const promises = [];
+    promises.push(new Promise(function (resolve, reject) {
+        proc.once('error', reject);
+        proc.once('exit', code => code ? reject(new Error(`Process terminated with code ${code}`)) : resolve());
+    }));
+    promises.push(stream.promises.pipeline(proc.stdout, stream_ytdlp_progress(), stream_each(progress_fn)));
+    promises.push(stream.promises.pipeline(proc.stderr, stream_each(v => console.log(`[stderr] ${v}`))));
+
+    await Promise.all(promises);
+}
+
+module.exports = shell_ytdlp_progress;

package/src/stream_curl_progress.js

@@ -0,0 +1,46 @@
+const stream = require('stream');
+const stream_filter = require('./stream_filter');
+const stream_lines = require('./stream_lines');
+const stream_map = require('./stream_map');
+const stream_skip = require('./stream_skip');
+
+function stream_curl_progress()
+{
+    return stream.compose(
+        stream_lines(),
+        stream_skip(2),
+        stream_map(function (v) {
+            // curl: (22) The requested URL returned error: 500
+            if (v.startsWith('curl:')) {
+                process.stderr.write(`${v}\n`);
+                return null;
+            }
+
+            // % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
+            //                                Dload  Upload   Total   Spent    Left  Speed
+            // 0 3217M    0     0    0  128k      0   205k  4:27:16 --:--:--  4:27:16  205k
+            // 0 3217M    0     0    0 6016k      0  3751k  0:14:38  0:00:01  0:14:37 3750k
+            // ...
+            // 18 3217M    0     0   18  587M      0  18.5M  0:02:53  0:00:31  0:02:22 19.0M
+            const [perc, total, perc2, recv, perc3, transferred, speed_down, speed_up, time_total, duration, eta, speed] = v.trim().split(/\s+/);
+            return {
+                perc,
+                done: recv === '0' ? transferred : recv,
+                total,
+                perc2,
+                recv,
+                perc3,
+                transferred,
+                speed_down,
+                speed_up,
+                time_total: time_total === '--:--:--' ? '~' : time_total,
+                duration: duration === '--:--:--' ? '~' : duration,
+                eta: eta === '--:--:--' ? '~' : eta,
+                speed
+            };
+        }),
+        stream_filter(v => v),
+    );
+}
+
+module.exports = stream_curl_progress;

package/src/stream_skip.js

@@ -0,0 +1,25 @@
+const stream = require('stream');
+
+/**
+ * Skip first `n` records.
+ */
+function stream_skip(n)
+{
+    let current = 0;
+    return new stream.Transform({
+        objectMode: true,
+        transform: function (item, encoding, callback) {
+            try {
+                if (current++ >= n) {
+                    this.push(item);
+                }
+                callback();
+            }
+            catch (error) {
+                callback(error);
+            }
+        },
+    });
+}
+
+module.exports = stream_skip;

package/src/stream_ytdlp_progress.js

@@ -0,0 +1,19 @@
+const stream = require('stream');
+const stream_filter = require('./stream_filter');
+const stream_lines = require('./stream_lines');
+const stream_map = require('./stream_map');
+
+function stream_ytdlp_progress()
+{
+    const re = /^\[download] (.*) of (.*) at (.*) ETA (.*)$/;
+    return stream.compose(
+        stream_lines(),
+        stream_map(function (v) {
+            const m = re.exec(v);
+            return !m ? false : {done: m[1].trim(), of: m[2].trim(), speed: m[3].trim(), eta: m[4].trim()};
+        }),
+        stream_filter(v => v),
+    );
+}
+
+module.exports = stream_ytdlp_progress;

package/src/user_friendly_status.js

@@ -0,0 +1,12 @@
+/**
+ * Concept. Represents a way to display a status of a currently running task to the end-user.
+ *
+ * @see countdown
+ * @see progress
+ */
+function user_friendly_status(s)
+{
+    console.log(s);
+}
+
+module.exports = user_friendly_status;