@vbarbarosh/node-helpers 1.0.1 → 1.1.3

package/README.md

@@ -2,7 +2,7 @@ A set of helpers for JavaScript/Node.js
 
 ## Installation
 
-    npm i @vbarbarosh/node-helpers
+    npm install vbarbarosh/node-helpers
 
 ## Test
 

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "1.0.1",
+    "version": "1.1.3",
     "description": "A set of helpers for JavaScript/Node.js",
     "files": [
         "src"
@@ -24,12 +24,16 @@
     },
     "peerDependencies": {
         "axios": "^0.21.1",
-        "form-data": "^4.0.0"
+        "bluebird": "^3.7.2",
+        "form-data": "^4.0.0",
+        "json-stable-stringify": "^1.0.1",
+        "sanitize-filename": "^1.6.3"
     },
     "devDependencies": {
         "@babel/preset-env": "^7.14.8",
         "@babel/register": "^7.14.5",
         "babel": "^6.23.0",
-        "mocha": "^9.0.2"
+        "mocha": "^9.0.2",
+        "throttle": "^1.0.3"
     }
 }

package/src/array_gcd.js

@@ -0,0 +1,16 @@
+// https://stackoverflow.com/a/39764792/1478566
+function array_gcd(array, fn = Number)
+{
+    return array.reduce((a,b) => gcd(fn(a), fn(b)));
+}
+
+// https://stackoverflow.com/a/39764792/1478566
+function gcd(a, b)
+{
+    if (b) {
+        return gcd(b, a % b);
+    }
+    return a;
+}
+
+export default array_gcd;

package/src/array_gcd.test.js

@@ -0,0 +1,10 @@
+import array_gcd from './array_gcd';
+import assert from 'assert';
+
+describe('array_gcd', function () {
+    it('should handle basic input', function () {
+        assert.deepStrictEqual(array_gcd([1,2,3,4,5]), 1);
+        assert.deepStrictEqual(array_gcd([4,8,16]), 4);
+        assert.deepStrictEqual(array_gcd([300,100,200,300]), 100);
+    });
+});

package/src/array_index.js

@@ -0,0 +1,8 @@
+function array_index(array, fn)
+{
+    const out = {};
+    array.forEach(v => out[fn(v)] = v);
+    return out;
+}
+
+export default array_index;

package/src/array_index.test.js

@@ -0,0 +1,14 @@
+import array_index from './array_index';
+import assert from 'assert';
+
+describe('array_index', function () {
+    it('should accept empty array', function () {
+        assert.deepStrictEqual(array_index([]), {});
+    });
+    it('should handle basic input', function () {
+        const a = {uid: 'a'};
+        const b = {uid: 'b'};
+        const c = {uid: 'c'};
+        assert.deepStrictEqual(array_index([a, b, c], v => v.uid), {a, b, c});
+    });
+});

package/src/array_sort.js

@@ -0,0 +1,23 @@
+import fcmp_strings from './fcmp_strings';
+
+/**
+ * Sort items in an `array`.
+ *
+ * @param array
+ * @param fn
+ * @param fcmp
+ * @returns {*}
+ */
+function array_sort(array, fn = identity, fcmp = fcmp_strings)
+{
+    return array.sort(function (a, b) {
+        return fcmp(fn(a), fn(b));
+    });
+}
+
+function identity(v)
+{
+    return v;
+}
+
+export default array_sort;

package/src/array_sort.test.js

@@ -0,0 +1,10 @@
+import array_sort from './array_sort';
+import assert from 'assert';
+
+describe('array_sort', function () {
+    it('should handle basic input', function () {
+        assert.deepStrictEqual(array_sort([5,4,3,2,1]), [1,2,3,4,5]);
+        assert.deepStrictEqual(array_sort([5,4,3,2,1], v => v), [1,2,3,4,5]);
+        assert.deepStrictEqual(array_sort([{id:5},{id:4},{id:3},{id:2},{id:1}], v => v.id), [{id:1},{id:2},{id:3},{id:4},{id:5}]);
+    });
+});

package/src/array_sort_other.js

@@ -2,21 +2,21 @@ import fcmp_strings from './fcmp_strings';
 
 /**
  * Sort items in an `array` at the same order as in `other`. Values which
- * are not in `other` are added to the end in the order defined by `fcmp`.
+ * are not in the `other` are added to the end of the result defined by `fcmp`.
  *
  * @param array
+ * @param fn
  * @param other
  * @param fcmp
  * @returns {*}
  */
-
-function array_sort_other(array, other, fcmp = fcmp_strings)
+function array_sort_other(array, fn, other, fcmp = fcmp_strings)
 {
     const other_map = {};
     other.forEach((v,i) => other_map[v] = i + 1);
     return array.sort(function (a, b) {
-        const ax = other_map[a];
-        const bx = other_map[b];
+        const ax = other_map[fn(a)];
+        const bx = other_map[fn(b)];
         if (ax && bx) {
             return ax - bx;
         }

package/src/array_sort_other.test.js

@@ -3,6 +3,7 @@ import assert from 'assert';
 
 describe('array_sort_other', function () {
     it('should handle basic input', function () {
-        assert.deepStrictEqual(array_sort_other([1,2,3,4,5], [5]), [5,1,2,3,4]);
+        assert.deepStrictEqual(array_sort_other([1,2,3,4,5], v => v, [5]), [5,1,2,3,4]);
+        assert.deepStrictEqual(array_sort_other([{id:1},{id:2},{id:3},{id:4},{id:5}], v => v.id, [5]), [{id:5},{id:1},{id:2},{id:3},{id:4}]);
     });
 });

package/src/array_sum.js

@@ -0,0 +1,10 @@
+function array_sum(array, fn = Number)
+{
+    let out = 0;
+    array.forEach(function (item) {
+        out += fn(item);
+    });
+    return out;
+}
+
+export default array_sum;

package/src/array_sum.test.js

@@ -0,0 +1,11 @@
+import array_sum from './array_sum';
+import assert from 'assert';
+
+describe('array_sum', function () {
+    it('should handle basic input', function () {
+        assert.deepStrictEqual(array_sum([1,2,3,4,5]), 15);
+    });
+    it('should cast strings to numbers', function () {
+        assert.deepStrictEqual(array_sum(['1','2','3','4','5']), 15);
+    });
+});

package/src/cli.js

@@ -0,0 +1,38 @@
+/**
+ * Entry point for Node CLI apps
+ *
+ * @link https://github.com/vbarbarosh/node-cli
+ */
+async function cli(main)
+{
+    // https://stackoverflow.com/a/46916601/1478566
+    const timer = setInterval(v => v, 1E9);
+
+    try {
+        return await main();
+    }
+    catch (error) {
+        console.error(error);
+        process.exit(1);
+    }
+    finally {
+        clearInterval(timer);
+    }
+}
+
+// import Promise from 'bluebird';
+//
+// // https://stackoverflow.com/a/57241059/1478566
+// function cli(main)
+// {
+//     // https://stackoverflow.com/a/46916601/1478566
+//     return Promise.method(main).call().catch(panic).finally(clearInterval.bind(null, setInterval(v=>v, 1E9)));
+// }
+//
+// function panic(error)
+// {
+//     console.error(error);
+//     process.exit(1);
+// }
+
+export default cli;

package/src/crypto_decrypt_aes256.js

@@ -0,0 +1,16 @@
+import crypto from 'crypto';
+
+/**
+ * @link https://nodejs.org/api/crypto.html#crypto_class_cipher
+ * @link https://attacomsian.com/blog/nodejs-encrypt-decrypt-data
+ */
+function crypto_decrypt_aes256(password, ivenc)
+{
+    const key = crypto.createHash('sha256').update(password).digest();
+    const iv = ivenc.slice(1, ivenc[0] + 1);
+    const enc = ivenc.slice(ivenc[0] + 1);
+    const decipher = crypto.createDecipheriv('aes-256-ctr', key, iv);
+    return Buffer.concat([decipher.update(enc), decipher.final()]);
+}
+
+export default crypto_decrypt_aes256;

package/src/crypto_encrypt_aes256.js

@@ -0,0 +1,18 @@
+import crypto from 'crypto';
+
+/**
+ * @link https://nodejs.org/api/crypto.html#crypto_class_cipher
+ * @link https://attacomsian.com/blog/nodejs-encrypt-decrypt-data
+ */
+function crypto_encrypt_aes256(password, data)
+{
+    const iv = crypto.randomBytes(16);
+    const key = crypto.createHash('sha256').update(password).digest();
+    const cipher = crypto.createCipheriv('aes-256-ctr', key, iv);
+    if (iv.length > 255) {
+        throw new Error('iv size is too big');
+    }
+    return Buffer.concat([Buffer.from([iv.length]), iv, cipher.update(data), cipher.final()]);
+}
+
+export default crypto_encrypt_aes256;

package/src/crypto_encrypt_aes256.test.js

@@ -0,0 +1,10 @@
+import assert from 'assert';
+import crypto_decrypt_aes256 from './crypto_decrypt_aes256';
+import crypto_encrypt_aes256 from './crypto_encrypt_aes256';
+
+describe('crypto_encrypt_aes256', function () {
+    it('should handle basic input', function () {
+        const password = 'pass123';
+        assert.deepStrictEqual(crypto_decrypt_aes256(password, crypto_encrypt_aes256(password, 'hello')).toString('utf8'), 'hello');
+    });
+});

package/src/crypto_hash_md5.js

@@ -0,0 +1,14 @@
+import crypto from 'crypto';
+
+/**
+ *
+ * @param data
+ * @returns {Buffer}
+ * @link https://nodejs.org/en/knowledge/cryptography/how-to-use-crypto-module/#how-to-calculate-hashes-with-crypto
+ */
+function crypto_hash_md5(data)
+{
+    return crypto.createHash('md5').update(data).digest();
+}
+
+export default crypto_hash_md5;

package/src/crypto_hash_sha256.js

@@ -0,0 +1,14 @@
+import crypto from 'crypto';
+
+/**
+ *
+ * @param data
+ * @returns {Buffer}
+ * @link https://nodejs.org/en/knowledge/cryptography/how-to-use-crypto-module/#how-to-calculate-hashes-with-crypto
+ */
+function crypto_hash_sha256(data)
+{
+    return crypto.createHash('sha256').update(data).digest();
+}
+
+export default crypto_hash_sha256;

package/src/crypto_hash_sha256.test.js

@@ -0,0 +1,10 @@
+import crypto_hash_sha256 from './crypto_hash_sha256';
+import assert from 'assert';
+
+describe('crypto_hash_sha256', function () {
+    it('should handle basic input', function () {
+        assert.deepStrictEqual(crypto_hash_sha256('').toString('hex'), 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+        assert.deepStrictEqual(crypto_hash_sha256('1').toString('hex'), '6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b');
+        assert.deepStrictEqual(crypto_hash_sha256('hello').toString('hex'), '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824');
+    });
+});

package/src/crypto_hmac_sha256.js

@@ -0,0 +1,15 @@
+import crypto from 'crypto';
+
+/**
+ *
+ * @param password
+ * @param data
+ * @returns {Buffer}
+ * @link https://nodejs.org/en/knowledge/cryptography/how-to-use-crypto-module/#hmac
+ */
+function crypto_hmac_sha256(password, data)
+{
+    return crypto.createHmac('sha256', password).update(data).digest();
+}
+
+export default crypto_hmac_sha256;

package/src/format_thousands.js

@@ -0,0 +1,7 @@
+// https://stackoverflow.com/a/2901298
+function format_thousands(x)
+{
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+export default format_thousands;

package/src/fs_append.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.appendFile);

package/src/fs_append_json.js

@@ -0,0 +1,9 @@
+import fs_append from './fs_append';
+import json_stringify_stable from './json_stringify_stable';
+
+function fs_append_json(file, value)
+{
+    return fs_append(file, json_stringify_stable(value) + '\n');
+}
+
+export default fs_append_json;

package/src/fs_assert_file_exists.js

@@ -0,0 +1,11 @@
+import fs_fi from './fs_fi';
+
+async function fs_assert_file_exists(file)
+{
+    const fi = await fs_fi(file);
+    if (!fi.isFile()) {
+        throw new Error(`Not a file: ${file}`);
+    }
+}
+
+export default fs_assert_file_exists;

package/src/fs_assert_file_readable.js

@@ -0,0 +1,14 @@
+import fs_fi from './fs_fi';
+
+async function fs_assert_file_readable(file)
+{
+    const fi = await fs_fi(file);
+    if (!fi.isFile()) {
+        throw new Error(`Not a file: ${file}`);
+    }
+    if (fi.mode & 0o111) {
+        throw new Error(`File is not readable by all: ${file}`);
+    }
+}
+
+export default fs_assert_file_readable;

package/src/fs_copy.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.copyFile);

package/src/fs_exists.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+
+async function fs_exists(path)
+{
+    return new Promise(function (resolve) {
+        fs.access(path, function (error) {
+            error ? resolve(false) : resolve(true);
+        });
+    });
+}
+
+export default fs_exists;

package/src/fs_fclose.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.close);

package/src/fs_fi.js

@@ -0,0 +1,55 @@
+import fs_lstat from './fs_lstat';
+import fs_path_basename from './fs_path_basename';
+import fs_path_dirname from './fs_path_dirname';
+import fs_path_resolve from './fs_path_resolve';
+import fs_readlink from './fs_readlink';
+
+async function fs_fi(pathname)
+{
+    const basename = fs_path_basename(pathname);
+    const fi = await fs_lstat(pathname);
+    fi.pathname = pathname;
+    fi.basename = basename;
+    flags(fi);
+    if (fi.isSymbolicLink()) {
+        const target = await fs_readlink(fi.pathname);
+        const target_pathname = fs_path_resolve(fs_path_dirname(pathname), target);
+        fi.target = target;
+        fi.target_fi = await fs_lstat(target_pathname);
+        fi.target_fi.pathname = target_pathname;
+        fi.target_fi.basename = fs_path_basename(target_pathname);
+        flags(fi.target_fi);
+    }
+    return fi;
+}
+
+function flags(fi)
+{
+    const tmp = [];
+    if (fi.isFile()) {
+        tmp.push('is_file');
+    }
+    if (fi.isDirectory()) {
+        tmp.push('is_directory');
+    }
+    if (fi.isBlockDevice()) {
+        tmp.push('is_block_device');
+    }
+    if (fi.isCharacterDevice()) {
+        tmp.push('is_character_device');
+    }
+    if (fi.isSymbolicLink()) {
+        tmp.push('is_symbolic_link');
+    }
+    if (fi.isFIFO()) {
+        tmp.push('is_fifo');
+    }
+    if (fi.isSocket()) {
+        tmp.push('is_socket');
+    }
+    fi.flags = tmp;
+    fi.flags_map = {};
+    tmp.forEach(key => fi.flags_map[key] = true);
+}
+
+export default fs_fi;

package/src/fs_find.js

@@ -0,0 +1,21 @@
+import Promise from 'bluebird';
+import fs_fi from './fs_fi';
+import fs_path_resolve from './fs_path_resolve';
+import fs_readdir from './fs_readdir';
+
+async function fs_find(pathname = '.')
+{
+    const fi = await fs_fi(fs_path_resolve(pathname));
+    if (fi.isDirectory()) {
+        const names = await fs_readdir(pathname);
+        const rows = await Promise.all(names.map(v => fs_find(fs_path_resolve(pathname, v))));
+        const out = [fi];
+        for (let i = 0, end = rows.length; i < end; ++i) {
+            out.push(...rows[i]);
+        }
+        return out;
+    }
+    return [fi];
+}
+
+export default fs_find;

package/src/fs_fopen.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.open);

package/src/fs_fopen_update.js

@@ -0,0 +1,34 @@
+import fs_fopen from './fs_fopen';
+
+// Main use case is uploading files in chunks. Each time
+// a chunk is uploaded do update a target file. At the end
+// you will have a ready to go file.
+
+async function fs_fopen_update(pathname)
+{
+    try {
+        // Open a file for updating...
+        return await fs_fopen(pathname, 'r+');
+    }
+    catch (error) {
+        if (error.code != 'ENOENT') {
+            throw error;
+        }
+    }
+
+    try {
+        // There is no such a file, try to create it...
+        return await fs_fopen(pathname, 'wx');
+    }
+    catch (error) {
+        if (error.code != 'EEXIST') {
+            throw error;
+        }
+    }
+
+    // Another process might have already created it, try to
+    // open for updating...
+    return fs_fopen(pathname, 'r+');
+}
+
+export default fs_fopen_update;

package/src/fs_fread.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+const read = util.promisify(fs.read);
+
+// Main use case is for reading chunks of data from file.
+
+async function fs_fread(fp, buffer, offset = null)
+{
+    const {bytesRead} = await read(fp, buffer, 0, buffer.length, offset);
+    return (bytesRead == buffer.length) ? buffer : buffer.slice(0, bytesRead);
+}
+
+export default fs_fread;

package/src/fs_fsize.js

@@ -0,0 +1,8 @@
+import fs_fstat from './fs_fstat';
+
+function fs_fsize(fp)
+{
+    return fs_fstat(fp).then(v => v.size);
+}
+
+export default fs_fsize;

package/src/fs_fstat.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.fstat);

package/src/fs_fwrite.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+const write = util.promisify(fs.write);
+
+// Main use case is for writing chunks of data to file.
+
+async function fs_fwrite(fp, buffer, offset = null)
+{
+    const {bytesWritten} = await write(fp, buffer, 0, buffer.length, offset);
+    return bytesWritten;
+}
+
+export default fs_fwrite;

package/src/fs_ls.js

@@ -0,0 +1,16 @@
+import Promise from 'bluebird';
+import fs_fi from './fs_fi';
+import fs_path_join from './fs_path_join';
+import fs_readdir from './fs_readdir';
+
+async function fs_ls(pathname = '.')
+{
+    const fi = await fs_fi(pathname);
+    if (fi.isDirectory()) {
+        const names = await fs_readdir(pathname);
+        return Promise.all(names.map(v => fs_fi(fs_path_join(pathname, v))));
+    }
+    return [fi];
+}
+
+export default fs_ls;

package/src/fs_lsr.js

@@ -0,0 +1,26 @@
+import Promise from 'bluebird';
+import fs_fi from './fs_fi';
+import fs_path_join from './fs_path_join';
+import fs_readdir from './fs_readdir';
+
+async function fs_lsr(pathname = '.')
+{
+    const fi = await fs_fi(pathname);
+    const ret = [fi];
+    if (fi.isDirectory()) {
+        fi.content_size = 0;
+        const names = await fs_readdir(pathname);
+        const all = await Promise.all(names.map(v => fs_lsr(fs_path_join(pathname, v))));
+        for (let i = 0, end = all.length; i < end; ++i) {
+            const rows = all[i];
+            ret.push(...rows);
+            fi.content_size += rows[0].content_size;
+        }
+    }
+    else {
+        fi.content_size = fi.isFile() ? fi.size : 0;
+    }
+    return ret;
+}
+
+export default fs_lsr;

package/src/fs_lstat.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.lstat);

package/src/fs_mkdir.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.mkdir);

package/src/fs_mkdirp.js

@@ -0,0 +1,26 @@
+import fs_lstat from './fs_lstat';
+import fs_mkdir from './fs_mkdir';
+import fs_path_dirname from './fs_path_dirname';
+
+async function fs_mkdirp(pathname)
+{
+    const parents = [];
+
+    for (let p = pathname; p && p != '/'; p = fs_path_dirname(p)) {
+        try {
+            await fs_lstat(p);
+            break;
+        }
+        catch (error) {
+            parents.unshift(p);
+        }
+    }
+
+    for (let i = 0, end = parents.length; i < end; ++i) {
+        await fs_mkdir(parents[i]);
+    }
+
+    return pathname;
+}
+
+export default fs_mkdirp;

package/src/fs_path_basename.js

@@ -0,0 +1,8 @@
+import path from 'path';
+
+function fs_path_basename(p)
+{
+    return path.basename(p);
+}
+
+export default fs_path_basename;

package/src/fs_path_dirname.js

@@ -0,0 +1,8 @@
+import path from 'path';
+
+function fs_path_dirname(p)
+{
+    return path.dirname(p);
+}
+
+export default fs_path_dirname;

package/src/fs_path_join.js

@@ -0,0 +1,8 @@
+import path from 'path';
+
+function fs_path_join(...parts)
+{
+    return path.join(...parts);
+}
+
+export default fs_path_join;

package/src/fs_path_resolve.js

@@ -0,0 +1,8 @@
+import path from 'path';
+
+function fs_path_resolve(...parts)
+{
+    return path.resolve(...parts);
+}
+
+export default fs_path_resolve;

package/src/fs_path_sanitize.js

@@ -0,0 +1,8 @@
+import sanitize_filename from 'sanitize-filename';
+
+function fs_path_sanitize(filename)
+{
+    return sanitize_filename(filename);
+}
+
+export default fs_path_sanitize;

package/src/fs_path_tempdir.js

@@ -0,0 +1,8 @@
+import os from 'os';
+
+function fs_path_tempdir()
+{
+    return os.tmpdir();
+}
+
+export default fs_path_tempdir;

package/src/fs_read.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.readFile);

package/src/fs_read_json.js

@@ -0,0 +1,10 @@
+import fs_read from './fs_read';
+
+// XXX Should support catchReturn, e.g.
+//     fs_read_json(file).catchReturn(default_value)
+function fs_read_json(file)
+{
+    return fs_read(file, {encoding: 'utf8'}).then(JSON.parse);
+}
+
+export default fs_read_json;

package/src/fs_read_stream.js

@@ -0,0 +1 @@
+export {createReadStream as default} from 'fs';

package/src/fs_read_utf8.js

@@ -0,0 +1,8 @@
+import fs_read from './fs_read';
+
+async function fs_read_utf8(file)
+{
+    return await fs_read(file, {encoding: 'utf8'});
+}
+
+export default fs_read_utf8;

package/src/fs_readdir.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.readdir);

package/src/fs_readlink.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.readlink);

package/src/fs_rename.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.rename);

package/src/fs_rm.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.unlink);

package/src/fs_rmdir.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.rmdir);

package/src/fs_rmrf.js

@@ -0,0 +1,25 @@
+import Promise from 'bluebird';
+import fs_fi from './fs_fi';
+import fs_rm from './fs_rm';
+import fs_rmdir from './fs_rmdir';
+import fs_path_resolve from './fs_path_resolve';
+import fs_readdir from './fs_readdir';
+
+async function fs_rmrf(pathname)
+{
+    const fi = await fs_fi(pathname).catch(() => null);
+    if (fi === null) {
+        return;
+    }
+
+    if (fi.isDirectory()) {
+        const names = await fs_readdir(pathname);
+        await Promise.all(names.map(v => fs_rmrf(fs_path_resolve(pathname, v))));
+        await fs_rmdir(fi.pathname);
+    }
+    else {
+        await fs_rm(fi.pathname);
+    }
+}
+
+export default fs_rmrf;

package/src/fs_size.js

@@ -0,0 +1,8 @@
+import fs_fi from './fs_fi';
+
+async function fs_size(file)
+{
+    return fs_fi(file).then(v => v.size);
+}
+
+export default fs_size;

package/src/fs_tempdir.js

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import fs_path_resolve from './fs_path_resolve';
+import fs_path_tempdir from './fs_path_tempdir';
+import fs_rmrf from './fs_rmrf';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+const mkdtemp = util.promisify(fs.mkdtemp);
+
+// * https://www.cons.org/cracauer/sigint.html from https://stackoverflow.com/q/14031763/1478566
+// * http://www.tldp.org/LDP/abs/html/exitcodes.html from https://stackoverflow.com/q/14031763/1478566
+// * https://www.exratione.com/2013/05/die-child-process-die/
+
+async function fs_tempdir(fn)
+{
+    process.on('SIGINT', sigint);
+
+    let d = null, out;
+    try {
+        d = await mkdtemp(fs_path_resolve(fs_path_tempdir(), 'vbtemp'));
+        out = await fn(d);
+    }
+    finally {
+        await clean();
+    }
+    return out;
+
+    async function clean() {
+        process.removeListener('SIGINT', sigint);
+        if (d) {
+            await fs_rmrf(d);
+        }
+    }
+
+    async function sigint() {
+        await clean().catch(function () {/* ignore */});
+        // https://stackoverflow.com/questions/14031763/doing-a-cleanup-action-just-before-node-js-exits#comment68567869_21947851
+        process.kill(process.pid, 'SIGINT');
+    }
+}
+
+export default fs_tempdir;

package/src/fs_write.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import util from 'util';
+
+// https://nodejs.org/api/util.html#util_util_promisify_original
+export default util.promisify(fs.writeFile);

package/src/fs_write_stream.js

@@ -0,0 +1 @@
+export {createWriteStream as default} from 'fs';

package/src/http_put_file.js

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import fs_size from './fs_size';
+import http from 'http';
+import https from 'https';
+
+async function http_put_file(url, file, options)
+{
+    // <?xml version="1.0" encoding="UTF-8"?>
+    // <Error>
+    //   <Code>NotImplemented</Code>
+    //   <Message>A header you provided implies functionality that is not implemented</Message>
+    //   <Header>Transfer-Encoding</Header>
+    //   <RequestId>XXXXXXXXXX</RequestId>
+    //   <HostId>YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY</HostId>
+    // </Error>
+
+    const total = await fs_size(file);
+    return new Promise(function (resolve, reject) {
+        const chunks = [];
+        const request = (url.startsWith('http:') ? http : https).request(url, {method: 'PUT', headers: {'Content-Length': total}}, function (response) {
+            response.on('error', reject);
+            if (options.progress_download) {
+                const total_download = response.headers['content-length'] ? parseInt(response.headers['content-length']) : null;
+                let ready = 0;
+                response.on('data', function (chunk) {
+                    const delta = chunk.length;
+                    ready += delta;
+                    options.progress_download(delta, ready, total_download);
+                });
+            }
+            response.on('data', function (chunk) {
+                chunks.push(chunk);
+            });
+            response.on('end', function () {
+                switch (response.statusCode) {
+                case 200:
+                    resolve({request, response, data: Buffer.concat(chunks)});
+                    break;
+                default:
+                    reject(new Error(`${response.statusCode} ${response.statusMessage}\n\n${Buffer.concat(chunks).toString('utf8')}`));
+                    break;
+                }
+            });
+        });
+        request.on('error', reject);
+        // https://stackoverflow.com/a/39492211/1478566
+        if (options.progress_upload) {
+            let prev = 0;
+            request.on('drain', function () {
+                const ready = request.socket.bytesWritten;
+                const delta = ready - prev;
+                options.progress_upload(delta, ready, total);
+                prev = ready;
+            });
+        }
+        fs.createReadStream(file).pipe(request);
+    });
+}
+
+export default http_put_file;

package/src/identity.js

@@ -0,0 +1,6 @@
+function identity(value)
+{
+    return value;
+}
+
+export default identity;

package/src/ignore.js

@@ -0,0 +1,5 @@
+function ignore()
+{
+}
+
+export default ignore;

package/src/json_stringify_stable.js

@@ -0,0 +1,3 @@
+import json_stringify_stable from 'json-stable-stringify';
+
+export default json_stringify_stable;

package/src/stream_data_ln.js

@@ -0,0 +1,42 @@
+/**
+ * Split stream on each \n and call `fn` for each line.
+ *
+ * @param stream
+ * @param fn
+ * @return function
+ */
+function stream_data_ln(stream, fn)
+{
+    let utf8 = '';
+    stream.on('data', data);
+    stream.on('end', end);
+    return off;
+
+    function off() {
+        stream.off('data', data);
+        stream.off('end', end);
+    }
+    function end() {
+        off();
+        if (utf8) {
+            fn(utf8, true);
+        }
+    }
+    function data(buffer) {
+        utf8 += buffer.toString('utf8');
+        for (let iteration = 1; true; ++iteration) {
+            if (iteration == 1000000) {
+                throw new Error('Too many iterations');
+            }
+            const i = utf8.indexOf('\n');
+            if (i == -1) {
+                break;
+            }
+            const line = utf8.substr(0, i);
+            utf8 = utf8.substr(i + 1);
+            fn(line, false);
+        }
+    }
+}
+
+export default stream_data_ln;

package/src/stream_data_ln.test.js

@@ -0,0 +1,15 @@
+import assert from 'assert';
+import fs from 'fs';
+import stream_data_ln from './stream_data_ln';
+import stream_promise from './stream_promise';
+
+describe('stream_data_ln', function () {
+    it('should handle basic input', async function () {
+        let tmp = '';
+        const s = fs.createReadStream(__filename);
+        const off = stream_data_ln(s, v => tmp += v + '\n');
+        await stream_promise(s);
+        off();
+        assert.deepStrictEqual(tmp, fs.readFileSync(__filename, {encoding: 'utf8'}));
+    });
+});

package/src/stream_promise.js

@@ -0,0 +1,62 @@
+import {finished} from 'stream/promises';
+
+// /**
+//  * Wait for a stream to finish with `await stream_promise(stream)`.
+//  *
+//  * @param stream
+//  * @returns {Promise}
+//  */
+// function stream_promise(stream)
+// {
+//     /**
+//      * https://stackoverflow.com/a/34310963/1478566
+//      * > end and finish are the same event BUT on different types of
+//      * > Streams.
+//      * >   * stream.Readable fires ONLY end and NEVER finish
+//      * >   * stream.Writable fires ONLY finish and NEVER end
+//      */
+//     return new Promise(function (resolve, reject) {
+//         stream.once('end', resolve); // Stream.Readable
+//         stream.once('finish', resolve); // Stream.Writable
+//         stream.once('error', reject);
+//         function end() { off(); resolve(); }
+//         function finish() { off(); resolve(); }
+//         function error() { off(); reject(); }
+//         function off() {
+//             stream.off('end', end);
+//             stream.off('finish', finish);
+//             stream.off('error', error);
+//         }
+//     });
+// }
+
+/**
+ * Wait for a stream to finish with `await stream_promise(stream)`.
+ *
+ * https://nodejs.org/api/stream.html#stream_stream_finished_stream_options_callback
+ * > Especially useful in error handling scenarios where a stream
+ * > is destroyed prematurely (like an aborted HTTP request), and
+ * > will not emit 'end' or 'finish'.
+ *
+ * @param stream
+ * @returns {Promise<void>}
+ */
+function stream_promise(stream)
+{
+    // https://nodejs.org/api/stream.html#stream_stream_finished_stream_options_callback
+    // > stream.finished() leaves dangling event listeners (in particular
+    // > 'error', 'end', 'finish' and 'close') after callback has been
+    // > invoked. The reason for this is so that unexpected 'error'
+    // > events (due to incorrect stream implementations) do not cause
+    // > unexpected crashes. If this is unwanted behavior then the
+    // > returned cleanup function needs to be invoked in the callback:
+    // >
+    // >     const cleanup = finished(rs, (err) => {
+    // >         cleanup();
+    // >         // ...
+    // >     });
+    // >
+    return finished(stream);
+}
+
+export default stream_promise;

package/src/stream_promise.test.js

@@ -0,0 +1,14 @@
+import fs from 'fs';
+import ignore from './ignore';
+import stream_promise from './stream_promise';
+
+describe('stream_promise', function () {
+    it('should handle ReadableStream', async function () {
+        this.timeout(100);
+        await stream_promise(fs.createReadStream(__filename).on('data', ignore));
+    });
+    it('should handle WritableStream', async function () {
+        this.timeout(100);
+        await stream_promise(fs.createWriteStream('/dev/null').end('hello\n'));
+    });
+});