@vbarbarosh/node-helpers 3.66.1 → 3.68.0

package/src/fcmp_default.js

@@ -0,0 +1,12 @@
+function fcmp_default(a, b)
+{
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+
+module.exports = fcmp_default;

package/src/fcmp_default_desc.js

@@ -0,0 +1,12 @@
+function fcmp_default_desc(b, a)
+{
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+
+module.exports = fcmp_default_desc;

package/src/fcmp_from_spec.js

@@ -1,6 +1,8 @@
 /**
  * Create fcmp from an array of props. For desc order a prop should be prefixed
  * with minus sign (e.g. -price).
+ *
+ * @deprecated Deprecated in favor of fcmpx
  */
 function fcmp_from_spec(props)
 {

package/src/fcmp_numbers.js

@@ -1,6 +1,6 @@
 function fcmp_numbers(a, b)
 {
-    return Number(a) - b;
+    return a - b;
 }
 
 module.exports = fcmp_numbers;

package/src/fcmp_tuples.js

@@ -0,0 +1,15 @@
+const fcmp_default = require('./fcmp_default');
+
+function fcmp_tuples(a, b, fcmp = fcmp_default)
+{
+    const end = Math.min(a.length, b.length);
+    for (let i = 0; i < end; ++i) {
+        const tmp = fcmp(a[i], b[i]);
+        if (tmp) {
+            return tmp;
+        }
+    }
+    return 0;
+}
+
+module.exports = fcmp_tuples;

package/src/fcmp_utf8_bin.js

@@ -0,0 +1,13 @@
+// Strict binary (codepoint) comparison, like MySQL's utf8_bin collation
+function fcmp_utf8_bin(a, b)
+{
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+
+module.exports = fcmp_utf8_bin;

package/src/fcmp_utf8_ci.js

@@ -0,0 +1,7 @@
+// Locale-aware, case-insensitive, like utf8_ci or utf8mb4_ci
+function fcmp_utf8_ci(a, b)
+{
+    return a.localeCompare(b, undefined, {sensitivity: 'base'});
+}
+
+module.exports = fcmp_utf8_ci;

package/src/fcmp_utf8_cs.js

@@ -0,0 +1,7 @@
+// Locale-aware, case-sensitive, like utf8_cs or utf8mb4_cs (but using system locale)
+function fcmp_utf8_cs(a, b)
+{
+    return a.localeCompare(b, undefined, {sensitivity: 'variant'});
+}
+
+module.exports = fcmp_utf8_cs;

package/src/fcmp_utf8_natural_ci.js

@@ -0,0 +1,7 @@
+// Natural sort (numeric), case-insensitive
+function fcmp_utf8_natural_ci(a, b)
+{
+    return a.localeCompare(b, undefined, {numeric: true, sensitivity: 'base'});
+}
+
+module.exports = fcmp_utf8_natural_ci;

package/src/fcmp_utf8_natural_cs.js

@@ -0,0 +1,7 @@
+// Natural sort (numeric), case-sensitive
+function fcmp_utf8_natural_cs(a, b)
+{
+    return a.localeCompare(b, undefined, {numeric: true, sensitivity: 'variant'});
+}
+
+module.exports = fcmp_utf8_natural_cs;

package/src/fcmpx.js

@@ -0,0 +1,120 @@
+const fcmp_default = require('./fcmp_default');
+const fcmp_default_desc = require('./fcmp_default_desc');
+const identity = require('./identity');
+
+const MISSING = Symbol('fcmpx.missing');
+
+/**
+ * Comparator builder using compact expressions.
+ *
+ * fcmp expression — Creates an `fcmp` function from an expression, suitable for use with `[].sort()`.
+ *
+ * fcmpx('user.email')
+ * fcmpx('-user.age,user.email')
+ * fcmpx(v => v.user.email)
+ * fcmpx(['user.age', 'user.email'])
+ * fcmpx(['-user.age', 'user.email'])
+ */
+function fcmpx(expr)
+{
+    if (typeof expr === 'string') {
+        if (expr.includes(',')) {
+            return fcmpx(expr.split(','));
+        }
+        return fcmpx_compile(expr);
+    }
+    if (!Array.isArray(expr)) {
+        return fcmpx_compile(expr);
+    }
+    const fcmp_items = expr.map(fcmpx_parse);
+    return function (a, b) {
+        const tuple1 = fcmp_items.map(v => v.read(a));
+        const tuple2 = fcmp_items.map(v => v.read(b));
+        for (let i = 0; i < fcmp_items.length; ++i) {
+            const tmp = fcmp_items[i].fcmp(tuple1[i], tuple2[i]);
+            if (tmp) {
+                return tmp;
+            }
+        }
+        return 0;
+    };
+}
+
+function fcmpx_compile(expr)
+{
+    const {read, fcmp} = fcmpx_parse(expr);
+    return function (a, b) {
+        return fcmp(read(a), read(b));
+    };
+}
+
+function fcmpx_parse(expr)
+{
+    if (typeof expr === 'function') {
+        return {read: fcmpx_compile_read(expr), fcmp: fcmp_wrapper(fcmp_default)};
+    }
+    if (typeof expr === 'string') {
+        const desc = expr.startsWith('-');
+        const read = desc ? fcmpx_compile_read(expr.slice(1)) : fcmpx_compile_read(expr);
+        const fcmp = fcmp_wrapper(desc ? fcmp_default_desc : fcmp_default);
+        return {read, fcmp};
+    }
+    const fcmp_user = expr.fcmp;
+    const read = fcmpx_compile_read(expr.read);
+    const desc = expr.desc ?? false;
+    const fcmp = fcmp_wrapper(desc ? (fcmp_user ? (b, a) => fcmp_user(a, b) : fcmp_default_desc) : (fcmp_user ?? fcmp_default));
+    if (Array.isArray(expr.top)) {
+        const priority = new Map(expr.top.map((v, i) => [v, i]));
+        return {read: v => priority.get(read(v)) ?? priority.size, fcmp};
+    }
+    if (Array.isArray(expr.bottom)) {
+        const priority = new Map(expr.bottom.map((v, i) => [v, i]));
+        return {read: v => priority.get(read(v)) ?? -1, fcmp};
+    }
+    return {read, fcmp};
+}
+
+function fcmpx_compile_read(read)
+{
+    if (read === undefined || read === '' || read === '.') {
+        return identity;
+    }
+    if (typeof read === 'function') {
+        return function (value) {
+            return read(value) ?? MISSING;
+        };
+    }
+    if (typeof read === 'string') {
+        const props = read.split('.');
+        const [a, b, c, d, e] = props;
+        switch (props.length) {
+        case 1: return v => v?.[a] ?? MISSING;
+        case 2: return v => v?.[a]?.[b] ?? MISSING;
+        case 3: return v => v?.[a]?.[b]?.[c] ?? MISSING;
+        case 4: return v => v?.[a]?.[b]?.[c]?.[d] ?? MISSING;
+        case 5: return v => v?.[a]?.[b]?.[c]?.[d]?.[e] ?? MISSING;
+        default: return v => props.reduce((a,p) => a?.[p], v) ?? MISSING;
+        }
+    }
+    return v => v?.[read] ?? MISSING;
+}
+
+// Sorting rule: Missing values are considered greater than any defined value
+// and are therefore placed after all defined values.
+function fcmp_wrapper(fcmp)
+{
+    return function (a, b) {
+        if (a === MISSING) {
+            if (b === MISSING) {
+                return 0;
+            }
+            return 1;
+        }
+        if (b === MISSING) {
+            return -1;
+        }
+        return fcmp(a, b);
+    };
+}
+
+module.exports = fcmpx;

package/src/fcmpx.md

@@ -0,0 +1,17 @@
+Comparator builder using compact expressions.
+
+fcmp expression — Creates an `fcmp` function from an expression, suitable for use with `[].sort()`.
+
+```js
+fcmpx('user.email')
+fcmpx('-user.age,user.email')
+fcmpx(v => v.user.email)
+fcmpx(['user.age', 'user.email'])
+fcmpx(['-user.age', 'user.email'])
+```
+
+Sorting rule: Missing values are considered greater than any defined value
+and are therefore placed after all defined values.
+
+- YouTube: [Сортировка объектов в JavaScript](https://www.youtube.com/watch?v=rHEH_JfQjL4)
+- https://github.com/vbarbarosh/speaking/tree/master/20250822-js-sort-fcmpx

package/src/fcmpx.test.js

@@ -0,0 +1,173 @@
+const assert = require('assert');
+const fcmpx = require('./fcmpx');
+
+const users = [
+    {id: 'fred|48|100', user: {name: 'fred', age: 48, balance: 100}},
+    {id: 'barney|36|-200', user: {name: 'barney', age: 36, balance: -200}},
+    {id: 'wilma|-|-', user: {name: 'wilma', tag: {short: 'foo', long: 'foofoo'}}},
+    {id: 'betty|32|-', user: {name: 'betty', tag: {short: 'bar', long: 'barbar'}, age: 32}},
+];
+
+// https://dummyjson.com/docs/products
+
+const products = [
+    {id: 1, name: 'Yoga Mat', category: 'Yoga', price: 25.99, brand: 'BalanceFrom', rating: 4.6, discount: 0.1, availability: 'in_stock'},
+    {id: 2, name: 'Adjustable Dumbbells', category: 'Strength', price: 199.99, brand: 'Bowflex', rating: 4.8, availability: 'preorder'},
+    {id: 3, name: 'Resistance Bands Set', category: 'Strength', price: 32.5, brand: 'Fit Simplify', rating: 4.5, discount: 0.15, availability: 'in_stock'},
+    {id: 4, name: 'Treadmill', category: 'Cardio', price: 899, brand: 'NordicTrack', rating: 4.7, availability: 'out_of_stock'},
+    {id: 5, name: 'Kettlebell 20lb', category: 'Strength', price: 45, brand: 'CAP Barbell', rating: 4.4, discount: 0.05, availability: 'in_stock'},
+    {id: 6, name: 'Foam Roller', category: 'Recovery', price: 19.99, brand: 'TriggerPoint', rating: 4.6, availability: 'limited'},
+    {id: 7, name: 'Exercise Bike', category: 'Cardio', price: 599, brand: 'Peloton', rating: 4.9, discount: 0.2, availability: 'in_stock'},
+    {id: 8, name: 'Pull-Up Bar', category: 'Strength', price: 29.95, brand: 'Iron Gym', rating: 4.3, availability: 'in_stock'},
+    {id: 9, name: 'Jump Rope', category: 'Cardio', price: 12.99, brand: 'WOD Nation', rating: 4.2, discount: 0.25, availability: 'limited'},
+    {id: 10, name: 'Ab Roller', category: 'Core', price: 21.49, brand: 'Perfect Fitness', rating: 4.5, availability: 'in_stock'},
+];
+
+const tests = [
+    {
+        description: 'missing: should move undefined values to the bottom',
+        items: [
+            {id: 'user1', user: {age: 48}},
+            {id: 'user2', user: {age: 36}},
+            {id: 'user3'},
+            {id: 'user4', user: {age: 32}},
+        ],
+        extract: v => v.id,
+        expressions: [
+            'user.age',
+            v => v.user?.age,
+            {read: 'user.age'},
+            {read: v => v.user?.age},
+            ['user.age'],
+            [v => v.user?.age],
+            [{read: 'user.age'}],
+            [{read: v => v.user?.age}],
+        ],
+        expected: ['user4', 'user2', 'user1', 'user3'],
+    },
+    {
+        description: 'missing: should move undefined values to the bottom #2',
+        items: [
+            {id: 'user1', user: {age: 48}},
+            {id: 'user2', user: {age: 36}},
+            {id: 'user3', user: {tag: {short: 'foo'}}},
+            {id: 'user4', user: {tag: {short: 'bar'}, age: 32}},
+        ],
+        extract: v => v.id,
+        expressions: [
+            'user.age,user.tag.short',
+            ['user.age', 'user.tag.short'],
+            [v => v.user.age, v => v.user.tag?.short],
+            [{read: 'user.age'}, {read: 'user.tag.short'}],
+            [{read: v => v.user.age}, {read: v => v.user.tag?.short}],
+        ],
+        expected: ['user4', 'user2', 'user1', 'user3'],
+    },
+    {
+        description: 'missing: should move undefined values to the bottom and keep their initial order',
+        items: [
+            {id: 'user1', user: {balance: 100}},
+            {id: 'user2', user: {balance: -200}},
+            {id: 'user3'},
+            {id: 'user4'},
+        ],
+        extract: v => v.id,
+        expressions: [
+            'user.balance',
+            v => v.user?.balance,
+            [v => v.user?.balance],
+        ],
+        expected: ['user2', 'user1', 'user3', 'user4'],
+    },
+    {
+        description: 'move undefined value to the bottom, keep their initial order',
+        items: users,
+        extract: v => v.id,
+        expressions: [
+            'user.balance,user.age',
+            [v => v.user.balance, v => v.user.age],
+        ],
+        expected: ['barney|36|-200', 'fred|48|100', 'betty|32|-', 'wilma|-|-'],
+    },
+    {
+        description: 'move undefined value to the bottom, keep their initial order',
+        items: users,
+        extract: v => v.id,
+        expressions: [
+            'user.balance,user.age',
+            [v => v.user.balance, v => v.user.age],
+        ],
+        expected: ['barney|36|-200', 'fred|48|100', 'betty|32|-', 'wilma|-|-'],
+    },
+    {
+        description: 'user.tag.short',
+        items: [
+            {user: {name: 'fred', age: 48}},
+            {user: {name: 'barney', age: 36}},
+            {user: {name: 'wilma', tag: {short: 'foo'}}},
+            {user: {name: 'betty', tag: {short: 'bar'}, age: 32}},
+        ],
+        extract: v => `${v.user.name}|${v.user.tag?.short ?? '-'}`,
+        expressions: [
+            'user.tag.short',
+            v => v.user.tag?.short,
+            [v => v.user.tag?.short],
+        ],
+        expected: ['betty|bar', 'wilma|foo', 'fred|-', 'barney|-'],
+    },
+    {
+        description: 'user.tag.short,user.age',
+        items: [
+            {user: {name: 'fred', age: 48}},
+            {user: {name: 'barney', age: 36}},
+            {user: {name: 'wilma', tag: {short: 'foo'}}},
+            {user: {name: 'betty', tag: {short: 'bar'}, age: 32}},
+        ],
+        extract: v => `${v.user.name}|${v.user.tag?.short ?? ''}|${v.user.age ?? ''}`,
+        expressions: [
+            'user.tag.short,user.age',
+            ['user.tag.short', 'user.age'],
+            [v => v.user.tag?.short, v => v.user.age],
+        ],
+        expected: ['betty|bar|32', 'wilma|foo|', 'barney||36', 'fred||48'],
+    },
+    {
+        description: 'top: move specified values to the top',
+        items: [
+            {id: 'task1', priority: 'normal'},
+            {id: 'task2', priority: 'low'},
+            {id: 'task3', priority: 'high'},
+            {id: 'task4', priority: 'normal'},
+        ],
+        extract: v => `${v.id}:${v.priority}`,
+        expressions: [
+            {read: 'priority', top: ['high']},
+        ],
+        expected: ['task3:high', 'task1:normal', 'task2:low', 'task4:normal'],
+    },
+    {
+        description: 'top: move specified values to the top #2',
+        items: [
+            {id: 'task1', priority: 'normal'},
+            {id: 'task2', priority: 'low'},
+            {id: 'task3', priority: 'high'},
+            {id: 'task4', priority: 'normal'},
+        ],
+        extract: v => `${v.id}:${v.priority}`,
+        expressions: [
+            {read: 'priority', top: ['high', 'normal', 'low']},
+        ],
+        expected: ['task3:high', 'task1:normal', 'task4:normal', 'task2:low'],
+    },
+];
+
+describe('fcmpx', function () {
+    tests.forEach(function (test) {
+        test.expressions.forEach(function (expr, i) {
+            it(`${test.description}: #${i + 1} | ${test.description}`, function () {
+                const actual = test.items.slice().sort(fcmpx(expr)).map(test.extract);
+                assert.deepStrictEqual(actual, test.expected);
+            });
+        });
+    });
+});

package/src/filter1_from_spec.md

@@ -0,0 +1,7 @@
+Creates a filtering function based on the following spec:
+
+1. Substrings are separated by `/`.
+2. Each substring may have special characters:
+   - `^`: Substring must appear at the beginning.
+   - `$`: Substring must appear at the end.
+   - `!`: Negates the condition (substring must not appear).

package/src/format_date_fs.js

@@ -0,0 +1,13 @@
+function format_date_fs(d)
+{
+    const ymd = d.getFullYear() + dd(d.getMonth() + 1) + dd(d.getDate());
+    const hms = dd(d.getHours()) + dd(d.getMinutes()) + dd(d.getSeconds());
+    return ymd + '_' + hms;
+}
+
+function dd(v)
+{
+    return v > 9 ? `${v}` : `0${v}`;
+}
+
+module.exports = format_date_fs;

package/src/format_date_human.js

@@ -0,0 +1,13 @@
+function format_date_human(d)
+{
+    const ymd = d.getFullYear() + '/' + dd(d.getMonth() + 1) + '/' + dd(d.getDate());
+    const hms = dd(d.getHours()) + ':' + dd(d.getMinutes()) + ':' + dd(d.getSeconds());
+    return ymd + ' ' + hms;
+}
+
+function dd(v)
+{
+    return v > 9 ? `${v}` : `0${v}`;
+}
+
+module.exports = format_date_human;

package/src/format_hrtime.md

@@ -0,0 +1 @@
+Return a human-readable representation of hrtime (the return value from `process.hrtime(hrtime0)`).

package/src/format_progress_bytes.js

@@ -1,22 +1,22 @@
 const format_bytes = require('./format_bytes');
 const format_percents = require('./format_percents');
 const format_seconds = require('./format_seconds');
-const is_number_gt = require('@vbarbarosh/type-helpers/src/is_number_gt');
+const is_num_gt = require('@vbarbarosh/type-helpers/src/is_num_gt');
 
 function format_progress_bytes({percents, total, done, rate, eta, duration})
 {
-    const bps = is_number_gt(rate, 0) ? `${format_bytes(rate)}/s` : '~';
+    const bps = is_num_gt(rate, 0) ? `${format_bytes(rate)}/s` : '~';
     if (done > total) {
         return `${format_bytes(done)} at ${bps} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(total, 0)) {
-        const eta_str = is_number_gt(eta, 0) ? format_seconds(eta) : '~';
+    if (is_num_gt(total, 0)) {
+        const eta_str = is_num_gt(eta, 0) ? format_seconds(eta) : '~';
         return `${format_percents(percents)} | ${format_bytes(done)} of ${format_bytes(total)} at ${bps} ETA ${eta_str} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(done, 0)) {
+    if (is_num_gt(done, 0)) {
         return `${format_bytes(done)} of ~ at ${bps} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(duration, 0)) {
+    if (is_num_gt(duration, 0)) {
         return `~ duration=${format_seconds(duration)}`;
     }
     return '~';

package/src/format_progress_kilo.js

@@ -1,22 +1,22 @@
 const format_kilo = require('./format_kilo');
 const format_percents = require('./format_percents');
 const format_seconds = require('./format_seconds');
-const is_number_gt = require('@vbarbarosh/type-helpers/src/is_number_gt');
+const is_num_gt = require('@vbarbarosh/type-helpers/src/is_num_gt');
 
 function format_progress_kilo({percents, total, done, rate, eta, duration})
 {
-    const speed = is_number_gt(rate, 0) ? `${format_kilo(rate)}/s` : '~';
+    const speed = is_num_gt(rate, 0) ? `${format_kilo(rate)}/s` : '~';
     if (done > total) {
         return `${format_kilo(done)} at ${speed} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(total, 0)) {
-        const eta_str = is_number_gt(eta, 0) ? format_seconds(eta) : '~';
+    if (is_num_gt(total, 0)) {
+        const eta_str = is_num_gt(eta, 0) ? format_seconds(eta) : '~';
         return `${format_percents(percents)} | ${format_kilo(done)} of ${format_kilo(total)} at ${speed} ETA ${eta_str} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(done, 0)) {
+    if (is_num_gt(done, 0)) {
         return `${format_kilo(done)} of ~ at ${speed} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(duration, 0)) {
+    if (is_num_gt(duration, 0)) {
         return `~ duration=${format_seconds(duration)}`;
     }
     return '~';

package/src/fs_fopen_update.md

@@ -0,0 +1,5 @@
+The main use case is uploading files in chunks.
+
+Each time a chunk is uploaded, update the target file.
+
+By the end, you will have a ready-to-use file.

package/src/fs_list.js

@@ -0,0 +1,16 @@
+const Promise = require('bluebird');
+const fs_fi = require('./fs_fi');
+const fs_path_join = require('./fs_path_join');
+const fs_readdir = require('./fs_readdir');
+
+async function fs_list(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];
+}
+
+module.exports = fs_list;

package/src/fs_list_deep.js

@@ -0,0 +1,20 @@
+const fs_fi = require('./fs_fi');
+const fs_path_join = require('./fs_path_join');
+const fs_readdir = require('./fs_readdir');
+
+async function fs_list_deep(path = '.')
+{
+    const out = [];
+    const queue = [path];
+    while (queue.length) {
+        const fi = await fs_fi(queue.pop());
+        out.push(fi);
+        if (fi.isDirectory()) {
+            const names = await fs_readdir(fi.pathname);
+            queue.push(...names.map(v => fs_path_join(fi.pathname, v)));
+        }
+    }
+    return out;
+}
+
+module.exports = fs_list_deep;

package/src/fs_ls.js

@@ -3,6 +3,9 @@ const fs_fi = require('./fs_fi');
 const fs_path_join = require('./fs_path_join');
 const fs_readdir = require('./fs_readdir');
 
+/**
+ * @deprecated Deprecated in favor or fs_list
+ */
 async function fs_ls(pathname = '.')
 {
     const fi = await fs_fi(pathname);

package/src/fs_path_extname.js

@@ -0,0 +1,14 @@
+const path = require('path');
+
+function fs_path_extname(p)
+{
+    return path.extname(p);
+}
+
+// function extname(s)
+// {
+//     const i = s.lastIndexOf('.');
+//     return (i > 0) ? s.slice(i) : null;
+// }
+
+module.exports = fs_path_extname;

package/src/fs_path_extname.test.js

@@ -0,0 +1,22 @@
+const assert = require('assert');
+const fs_path_extname = require('./fs_path_extname');
+
+const tests = [
+    ['.', ''],
+    ['..', ''],
+    ['.foo', ''],
+    ['..foo', '.foo'],
+    ['.foo.bar', '.bar'],
+    ['fs_path_extname.js', '.js'],
+    ['/path/to/file.js', '.js'],
+    ['/path/to/file.js/foo', ''],
+];
+
+describe('fs_path_extname', function () {
+    tests.forEach(function ([input, expected]) {
+        it(`${input} -> ${expected}`, function () {
+            const actual = fs_path_extname(input);
+            assert.strictEqual(actual, expected);
+        });
+    });
+});

package/src/fs_size_enoent.md

@@ -0,0 +1,3 @@
+Returns the size of a file, or 0 if the file is not present.
+
+It was created for cases when you need to resume a download.

package/src/fs_tempdir.md

@@ -0,0 +1,6 @@
+```js
+await fs_tempdir(async function (d) {
+    await fs_write(`${d}/input.txt`, 'hello');
+    await shell(['ls', '-alh'], {cwd: d});
+});
+```

package/src/now_atom.js

@@ -1,5 +1,5 @@
 /**
- * Return current date in ATOM format (e.g. "2021-07-17T23:27:01.030Z")
+ * Return the current date in ATOM format (e.g. "2021-07-17T23:27:01.030Z")
  *
  * @returns {string}
  * @link https://www.php.net/manual/en/class.datetimeinterface.php#datetime.constants.atom

package/src/now_atom.md

@@ -0,0 +1 @@
+Return the current date in ATOM format (e.g. "2021-07-17T23:27:01.030Z")

package/src/now_fs.js

@@ -0,0 +1,8 @@
+const format_date_fs = require('./format_date_fs');
+
+function now_fs()
+{
+    return format_date_fs(new Date());
+}
+
+module.exports = now_fs;

package/src/now_human.js

@@ -0,0 +1,8 @@
+const format_date_human = require('./format_date_human');
+
+function now_human()
+{
+    return format_date_human(new Date());
+}
+
+module.exports = now_human;