@vbarbarosh/node-helpers 3.17.0 → 3.18.0

package/README.md

@@ -12,6 +12,9 @@ A set of helpers for JavaScript/Node.js
 
 `concurrency` - limit for parallel processes.
 
+`user_friendly_status` - a function that accepts a string ready to present for the end-user (i.e.
+string which is guaranteed contains no sensitive information like usernames or passwords).
+
 * [Node • Stream • readable.every](https://nodejs.org/api/stream.html#readableeveryfn-options)
 * [Node • Stream • readable.filter](https://nodejs.org/api/stream.html#readablefilterfn-options)
 * [Node • Stream • readable.find](https://nodejs.org/api/stream.html#readablefindfn-options)

package/package.json

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

package/src/fastdl.js

@@ -3,7 +3,7 @@ const format_seconds = require('./format_seconds');
 const format_thousands = require('./format_thousands');
 const fs = require('fs');
 const fs_path_basename = require('./fs_path_basename');
-const make_progress = require('./progress');
+const make_progress = require('./make_progress');
 const parallel = require('./parallel');
 const stream = require('stream');
 

package/src/format_percents.js

@@ -0,0 +1,6 @@
+function format_percents(v)
+{
+    return (v*100).toFixed(2).replace(/\.0+$/, '') + '%';
+}
+
+module.exports = format_percents;

package/src/format_percents.test.js

@@ -0,0 +1,17 @@
+const assert = require('assert');
+const format_percents = require('./format_percents');
+
+const items = [
+    ['', '0%'],
+    [0, '0%'],
+    [0.5, '50%'],
+    [1, '100%'],
+];
+
+describe('format_percents', function () {
+    items.forEach(function ([input, expected]) {
+        it(`${input} → ${expected}`, function () {
+            assert.strictEqual(expected, format_percents(input));
+        });
+    });
+});

package/src/http_get_stream_range.js

@@ -9,7 +9,13 @@ async function http_get_stream_range(url, first, last)
     const headers = {Range: `bytes=${a}-${b}`};
     const res = await axios.get(url, {responseType: 'stream', headers});
     const out = res.data;
-    out.content_range = parse_http_content_range(res.headers['content-range']);
+    if (res.headers['content-range']) {
+        out.content_range = parse_http_content_range(res.headers['content-range']);
+    }
+    else {
+        const len = res.headers['content-length'];
+        out.content_range = parse_http_content_range(`${res.headers['accept-ranges']} 0-${len}/${len}`);
+    }
     if (a && out.content_range.first !== a) {
         out.destroy(new Error(`First byte of a returned range (${format_thousands(out.content_range.first)}) is not as expected: [${format_thousands(a)}]`));
     }

package/src/{progress.js → make_progress.js}

@@ -2,11 +2,11 @@
 // - update progress by replacing total amount
 // - render eta
 // - render items/second
-// - render percentage
+// - render percents
 // - time spent
 //
 // https://bramcohen.livejournal.com/24122.html
-function progress(total)
+function make_progress(total)
 {
     const history = [];
     const time0 = Date.now();
@@ -19,12 +19,12 @@ function progress(total)
         rate: null,
         duration: 0,
         progress: null,
-        percentage: null,
+        percents: null,
         add: function (delta = 0) {
-            const now_minus_2sec = Date.now() - 2000;
+            const now_minus_5sec = Date.now() - 5000;
             history.push({time: Date.now(), delta});
-            // Keep last 2 seconds
-            history.splice(0, history.findLastIndex(v => v.time < now_minus_2sec));
+            // Keep last 5 seconds
+            history.splice(0, history.findLastIndex(v => v.time < now_minus_5sec));
             out.done += delta;
             out.refresh();
         },
@@ -43,11 +43,11 @@ function progress(total)
                 out.rate = out.done/out.duration;
             }
             out.duration = (Date.now() - time0)/1000;
-            out.percentage = !out.total ? null : out.done/out.total;
+            out.percents = !out.total ? null : out.done/out.total;
             out.eta = !out.total ? null : (out.total - out.done)/out.rate;
         },
     };
     return out;
 }
 
-module.exports = progress;
+module.exports = make_progress;

package/src/stream_discard.js

@@ -0,0 +1,12 @@
+const stream = require('stream');
+
+function stream_discard()
+{
+    return new stream.Writable({
+        write: function (buf, encoding, next) {
+            next();
+        },
+    });
+}
+
+module.exports = stream_discard;

package/src/stream_progress.js

@@ -0,0 +1,33 @@
+const format_bytes = require('./format_bytes');
+const format_percents = require('./format_percents');
+const format_seconds = require('./format_seconds');
+const make_progress = require('./make_progress');
+const stream = require('stream');
+
+/**
+ * Monitor the progress of data through a pipe. Similar to UNIX `pv` command.
+ */
+function stream_progress({total, user_friendly_status = s => console.log(s)})
+{
+    let done = 0;
+    const timer = setInterval(tick, 1000);
+    const progress = make_progress(total);
+    return new stream.Transform({
+        destroy: function (error, next) {
+            tick();
+            clearInterval(timer);
+            next();
+        },
+        transform: function (buf, encoding, next) {
+            done += buf.length;
+            this.push(buf, encoding);
+            next();
+        },
+    });
+    function tick() {
+        progress.update(done);
+        user_friendly_status(`${format_percents(progress.percents)} | ${format_bytes(done)} of ${format_bytes(total)} at ${format_bytes(progress.rate)}/s ETA ${format_seconds(progress.eta)} duration=${format_seconds(progress.duration)}`);
+    }
+}
+
+module.exports = stream_progress;

package/src/stream_strpbrk.js

@@ -8,10 +8,10 @@ function stream_strpbrk(chars = '\r\n')
     const pending = [];
     return new stream.Transform({
         objectMode: true,
-        decodeStrings: true,
         transform: function (str, encoding, next) {
-            for (let off = 0; off < str.length; ) {
+            str = Buffer.isBuffer(str) ? str.toString() : str;
 
+            for (let off = 0; off < str.length; ) {
                 // skip consecutive delimiters
                 while (off < str.length) {
                     let stop = true;

package/src/stream_strpbrk.test.js

@@ -14,6 +14,8 @@ const items = [
     ['a|||b → a,b', '|', ['a|||b'], ['a', 'b']],
     ['abc → abc', '|', ['a', 'b', 'c'], ['abc']],
     ['a|b;c', '|;', ['a|b;c'], ['a', 'b', 'c']],
+    ['Buffer(a) → a', '|', ['a'].map(Buffer.from), ['a']],
+    ['Buffer(a|b) → a,b', '|', ['a|b'].map(Buffer.from), ['a', 'b']],
 ];
 
 describe('stream_strpbrk', function () {

package/src/pv.js

@@ -1,27 +0,0 @@
-const eta = require('./eta');
-const format_bytes = require('./format_bytes');
-const format_seconds = require('./format_seconds');
-
-/**
- * Monitor the progress of data through a pipe.
- */
-async function* pv(stream, {total, resumed, log = s => console.log(s)})
-{
-    let read = 0;
-    const time0 = Date.now();
-    for await (const chunk of stream) {
-        read += chunk.length;
-        const seconds = (Date.now() - time0)/1000;
-        const bps = read/seconds;
-        if (total) {
-            const done = read + (resumed || 0);
-            log(`${format_bytes(done)} of ${format_bytes(total)} at ${format_bytes(bps)}/s ETA ${eta(time0, total, done, resumed)}`);
-        }
-        else {
-            log(`[${format_seconds(seconds)}] ${format_bytes(read)} at ${format_bytes(bps)}/s`);
-        }
-        yield chunk;
-    }
-}
-
-module.exports = pv;