@vbarbarosh/node-helpers 3.30.1 → 3.31.0

package/package.json

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

package/src/stream_discard.js

@@ -3,8 +3,8 @@ const stream = require('stream');
 function stream_discard()
 {
     return new stream.Writable({
-        write: function (buf, encoding, next) {
-            next();
+        write: function (buffer, encoding, callback) {
+            callback();
         },
     });
 }

package/src/stream_each.js

@@ -0,0 +1,17 @@
+const stream = require('stream');
+
+/**
+ * Pass each item to a simple function. This is a final step.
+ */
+function stream_each(fn)
+{
+    return stream.Writable({
+        objectMode: true,
+        write: function (item, encoding, callback) {
+            fn(item);
+            callback();
+        }
+    });
+}
+
+module.exports = stream_each;

package/src/stream_filter.js

@@ -0,0 +1,24 @@
+const stream = require('stream');
+
+/**
+ * Pass down only those items passed user-defined criteria.
+ */
+function stream_filter(fn)
+{
+    return new stream.Transform({
+        objectMode: true,
+        transform: function (item, encoding, callback) {
+            try {
+                if (fn(item)) {
+                    this.push(item);
+                }
+                callback();
+            }
+            catch (error) {
+                callback(error);
+            }
+        },
+    });
+}
+
+module.exports = stream_filter;

package/src/stream_group.js

@@ -2,24 +2,26 @@ const stream = require('stream');
 
 /**
  * Returns a transform stream used to group object into chunks of objects.
+ *
+ * TODO Rename to stream_chunk
  */
 function stream_group(chunk_size)
 {
     const chunk = [];
     return new stream.Transform({
         objectMode: true,
-        transform: function (item, encoding, next) {
+        transform: function (item, encoding, callback) {
             chunk.push(item);
             if (chunk.length >= chunk_size) {
                 this.push(chunk.splice(0));
             }
-            next();
+            callback();
         },
-        flush: function (next) {
+        flush: function (callback) {
             if (chunk.length) {
                 this.push(chunk.splice(0));
             }
-            next();
+            callback();
         },
     });
 }

package/src/stream_hash.js

@@ -5,13 +5,13 @@ function stream_hash(algorithm = 'md5', options)
 {
     const hash = crypto.createHash(algorithm, options);
     return new stream.Transform({
-        transform: function (chunk, encoding, next) {
+        transform: function (chunk, encoding, callback) {
             hash.update(chunk);
-            next();
+            callback();
         },
-        flush: function (next) {
+        flush: function (callback) {
             this.push(hash.digest('hex'));
-            next();
+            callback();
         },
     });
 }

package/src/stream_map.js

@@ -0,0 +1,22 @@
+const stream = require('stream');
+
+/**
+ * Transform each item by simple function.
+ */
+function stream_map(fn)
+{
+    return new stream.Transform({
+        objectMode: true,
+        transform: function (item, encoding, callback) {
+            try {
+                this.push(fn(item));
+                callback();
+            }
+            catch (error) {
+                callback(error);
+            }
+        },
+    });
+}
+
+module.exports = stream_map;

package/src/stream_md5.js

@@ -1,17 +1,20 @@
 const crypto = require('crypto');
 const stream = require('stream');
 
+/**
+ * TODO Rename to stream_hash_md5
+ */
 function stream_md5()
 {
     const md5 = crypto.createHash('md5');
     return new stream.Transform({
-        transform: function (chunk, encoding, next) {
+        transform: function (chunk, encoding, callback) {
             md5.update(chunk, encoding);
-            next();
+            callback();
         },
-        flush: function (next) {
+        flush: function (callback) {
             this.push(md5.digest('hex'));
-            next();
+            callback();
         },
     });
 }

package/src/stream_multiplex.js

@@ -10,38 +10,38 @@ function stream_multiplex(...streams)
     // `new stream.Writable()` will ignore second, third, etc. calls to `destroy`
     return stream.Writable({
         objectMode: true,
-        construct: function (next) {
+        construct: function (callback) {
             streams.forEach(s => s.once('error', e => this.destroy(e)));
-            next();
+            callback();
         },
-        destroy: async function (error, next) {
+        destroy: async function (error, callback) {
             let done = 0;
             streams.forEach(function (stream) {
                 stream.destroy(error, function () {
                     if (++done === streams.length) {
-                        next();
+                        callback();
                     }
                 });
             });
         },
-        write: async function (chunk, encoding, next) {
+        write: async function (chunk, encoding, callback) {
             let done = 0;
             streams.forEach(function (stream) {
                 stream.write(chunk, encoding, function (error) {
                     if (++done === streams.length || error) {
-                        next(error);
-                        next = ignore;
+                        callback(error);
+                        callback = ignore;
                     }
                 });
             });
         },
-        final: async function (next) {
+        final: async function (callback) {
             let done = 0;
             streams.forEach(function (stream) {
                 stream.end(function (error) {
                     if (++done === streams.length || error) {
-                        next(error);
-                        next = ignore;
+                        callback(error);
+                        callback = ignore;
                     }
                 });
             });

package/src/stream_parse_xml.js

@@ -47,13 +47,13 @@ function stream_parse_xml(selector, mapper = stream_parse_xml.guess)
     const parser = new htmlparser2.Parser(events, options);
     return out = new stream.Transform({
         objectMode: true,
-        transform: function (buf, encoding, next) {
+        transform: function (buf, encoding, callback) {
             parser.write(buf.toString());
-            next();
+            callback();
         },
-        flush: function (next) {
+        flush: function (callback) {
             parser.end();
-            next();
+            callback();
         },
     });
 }

package/src/stream_progress.js

@@ -7,21 +7,28 @@ const stream = require('stream');
  *
  * @similar https://www.npmjs.com/package/progress-stream
  */
-function stream_progress({total, user_friendly_status = s => console.log(s)} = {})
+function stream_progress({objectMode = false, 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) {
+        objectMode,
+        destroy: function (error, callback) {
             tick();
             clearInterval(timer);
-            next();
+            callback();
         },
-        transform: function (buf, encoding, next) {
-            done += buf.length;
-            this.push(buf, encoding);
-            next();
+        transform: function (buffer, encoding, callback) {
+            if (objectMode) {
+                done++;
+                this.push(buffer);
+            }
+            else {
+                done += buffer.length;
+                this.push(buffer, encoding);
+            }
+            callback();
         },
     });
     function tick() {

package/src/stream_promise.js

@@ -40,6 +40,7 @@ const {finished} = require('stream/promises');
  *
  * @param stream
  * @returns {Promise<void>}
+ * @deprecated Deprecated in favor of `stream.promises.finished`. Should be removed in the next major release.
  */
 function stream_promise(stream)
 {

package/src/stream_strpbrk.js

@@ -8,7 +8,7 @@ function stream_strpbrk(chars = '\r\n')
     const pending = [];
     return new stream.Transform({
         objectMode: true,
-        transform: function (str, encoding, next) {
+        transform: function (str, encoding, callback) {
             str = Buffer.isBuffer(str) ? str.toString() : str;
 
             let off = 0;
@@ -55,7 +55,7 @@ function stream_strpbrk(chars = '\r\n')
                     if (tmp.length) {
                         pending.push(tmp);
                     }
-                    next();
+                    callback();
                     return;
                 }
 
@@ -64,13 +64,13 @@ function stream_strpbrk(chars = '\r\n')
                 this.push(''.concat(...pending.splice(0)));
                 off = delims[0];
             }
-            next();
+            callback();
         },
-        flush: function (next) {
+        flush: function (callback) {
             if (pending.length) {
                 this.push(''.concat(...pending.splice(0)));
             }
-            next();
+            callback();
         },
     });
 }

package/src/stream_through.js

@@ -7,14 +7,14 @@ function stream_through(fn)
 {
     return new stream.Transform({
         objectMode: true,
-        transform: function (item, encoding, next) {
+        transform: function (item, encoding, callback) {
             try {
                 fn(item);
                 this.push(item, encoding);
-                next();
+                callback();
             }
             catch (error) {
-                next(error);
+                callback(error);
             }
         },
     });

package/src/stream_transform.js

@@ -1,5 +1,8 @@
 const stream = require('stream');
 
+/**
+ * @deprecated Deprecated in favor of stream_map
+ */
 function stream_transform(fn)
 {
     return new stream.Transform({