@vbarbarosh/node-helpers 3.34.1 → 3.35.0

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "3.34.1",
+    "version": "3.35.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_thru.js

@@ -1,8 +1,8 @@
-const shell = require('./shell');
+const shell_spawn = require('./shell_spawn');
 
 function shell_thru(args, options)
 {
-    return shell(args, {stdio: 'inherit', ...options});
+    return shell_spawn(args, {stdio: 'inherit', ...options});
 }
 
 module.exports = shell_thru;

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_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;