@vbarbarosh/node-helpers 3.74.0 → 3.74.1

package/README.md

@@ -20,7 +20,7 @@ npm install @vbarbarosh/node-helpers
 A subset of `@vbarbarosh/node-helpers` is available for browser:
 
 ```html
-<script src="https://unpkg.com/@vbarbarosh/node-helpers@3.74.0/dist/browser.js"></script>
+<script src="https://unpkg.com/@vbarbarosh/node-helpers@3.74.1/dist/browser.js"></script>
 ```
 
 ⚠️ All browser functions are exposed globally.

package/dist/browser.js

@@ -2484,10 +2484,10 @@ var __webpack_exports__ = {};
   \******************************/
 const ns = new URL(document.currentScript.src).searchParams.get('var') ?? 'h';
 if (typeof window[ns] !== 'undefined') {
-    console.log(`❌ @vbarbarosh/node-helpers@${"3.74.0"} was not injected — window.${ns} is already in use`);
+    console.log(`❌ @vbarbarosh/node-helpers@${"3.74.1"} was not injected — window.${ns} is already in use`);
 }
 else {
-    console.log(`🎉 @vbarbarosh/node-helpers@${"3.74.0"} successfully exposed as window.${ns}`);
+    console.log(`🎉 @vbarbarosh/node-helpers@${"3.74.1"} successfully exposed as window.${ns}`);
     window[ns] = {};
     // https://github.com/webpack/webpack/issues/625
     // https://webpack.js.org/guides/dependency-management/#require-context

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "3.74.0",
+    "version": "3.74.1",
     "description": "A set of helpers for JavaScript/Node.js",
     "unpkg": "dist/browser.js",
     "jsdelivr": "dist/browser.js",

package/src/cache.js

@@ -0,0 +1,15 @@
+// read, write, refresh
+async function cache({get, set, refresh})
+{
+    try {
+        return await get();
+    }
+    catch {
+    }
+
+    const value = await refresh();
+    await set(value);
+    return value;
+}
+
+module.exports = cache;

package/src/cache.md

@@ -0,0 +1,9 @@
+Probably the most basic cache engine ever.
+
+```javascript
+await cache({
+    get: () => fs_read_json('data.json'),
+    set: v => fs_write_json('data.json', v),
+    refresh: () => compute(),
+});
+```

package/src/urlmod.test.js

@@ -32,4 +32,9 @@ describe('urlmod', function () {
         assert.deepEqual(urlmod('/#ex', {b: 2}), '/?b=2#ex');
         assert.deepEqual(urlmod('http://www.example.com/some/path?a=1#ex', {b: 2}), 'http://www.example.com/some/path?a=1&b=2#ex');
     });
+    it('should keep port', function () {
+        const actual = urlmod('http://localhost:3000/auth/sign-in', {return: '/auth/profile'});
+        const expected = 'http://localhost:3000/auth/sign-in?return=%2Fauth%2Fprofile';
+        assert.strictEqual(actual, expected);
+    })
 });

package/src/urlparts.js

@@ -0,0 +1,20 @@
+function urlparts(url)
+{
+    const tmp = url instanceof URL
+        ? url
+        : new URL((typeof url === 'string' ? url : ''), 'fake://fake/');
+    return {
+        href: tmp.href,
+        protocol: tmp.protocol,
+        hostname: tmp.hostname,
+        username: tmp.username,
+        password: tmp.password,
+        host: tmp.host,
+        port: tmp.port,
+        path: tmp.pathname,
+        search: tmp.search,
+        hash: tmp.hash,
+    };
+}
+
+module.exports = urlparts;

package/src/urlparts.test.js

@@ -0,0 +1,294 @@
+const assert = require('assert');
+const edge_values = require('@vbarbarosh/type-helpers/src/edge_values');
+const urlparts = require('./urlparts');
+
+const extra_edge_values = [
+    // whitespace strings
+    {label: '" "', value: ' '},
+    {label: '"\\t"', value: '\t'},
+    {label: '"\\n"', value: '\n'},
+    {label: '"\\r\\n"', value: '\r\n'},
+
+    // numeric strings
+    {label: '"0"', value: '0'},
+    {label: '"1"', value: '1'},
+    {label: '"NaN"', value: 'NaN'},
+    {label: '"Infinity"', value: 'Infinity'},
+
+    // weird unicode
+    {label: '"💩"', value: '💩'},
+    {label: '"😀"', value: '😀'},
+    {label: '"привет"', value: 'привет'},
+    {label: '"こんにちは"', value: 'こんにちは'},
+
+    // dangerous chars
+    {label: '"<script>"', value: '<script>'},
+    {label: '"../"', value: '../'},
+    {label: '"%20"', value: '%20'},
+    {label: '"a?b=c"', value: 'a?b=c'},
+    {label: '"a#b"', value: 'a#b'},
+
+    // arrays
+    {label: '[1,2,3]', value: [1, 2, 3]},
+    {label: '[null]', value: [null]},
+    {label: '[undefined]', value: [undefined]},
+    {label: 'new Array(5)', value: new Array(5)},
+
+    // typed arrays
+    {label: 'Uint8Array', value: new Uint8Array([1, 2, 3])},
+    {label: 'Buffer', value: Buffer.from('abc')},
+
+    // objects
+    {label: '{a:1}', value: {a: 1}},
+    {label: 'Object.create(null)', value: Object.create(null)},
+
+    // custom coercion
+    {label: 'toString() => x', value: {toString() {return 'x';}}},
+    {label: 'valueOf() => 123', value: {valueOf() {return 123;}}},
+
+    // dates
+    {label: 'new Date()', value: new Date()},
+    {label: 'Invalid Date', value: new Date('invalid')},
+
+    // regexp
+    {label: '/foo/g', value: /foo/g},
+
+    // maps/sets
+    {label: 'Map', value: new Map()},
+    {label: 'Set', value: new Set()},
+    {label: 'WeakMap', value: new WeakMap()},
+    {label: 'WeakSet', value: new WeakSet()},
+
+    // promises
+    {label: 'Promise.resolve(1)', value: Promise.resolve(1)},
+
+    // errors
+    {label: 'Error', value: new Error('boom')},
+    {label: 'TypeError', value: new TypeError('boom')},
+
+    // wrappers
+    {label: 'new String()', value: new String('abc')},
+    {label: 'new Number()', value: new Number(123)},
+    {label: 'new Boolean()', value: new Boolean(false)},
+
+    // url-like
+    {label: 'new URL("https://example.com")', value: new URL('https://example.com')},
+
+    // bigint
+    {label: '1n', value: 1n},
+    {label: '-1n', value: -1n},
+
+    // special numbers
+    {label: 'Number.EPSILON', value: Number.EPSILON},
+
+    // proxy
+    {label: 'Proxy', value: new Proxy({}, {})},
+];
+
+const happy_paths = [
+    {
+        label: 'parses full https url',
+        input: 'https://john:secret@example.com:8080/users/15?page=2#top',
+        expected: {
+            href: 'https://john:secret@example.com:8080/users/15?page=2#top',
+            protocol: 'https:',
+            hostname: 'example.com',
+            username: 'john',
+            password: 'secret',
+            host: 'example.com:8080',
+            port: '8080',
+            path: '/users/15',
+            search: '?page=2',
+            hash: '#top',
+        },
+    },
+    {
+        label: 'parses https url without auth',
+        input: 'https://example.com/users',
+        expected: {
+            href: 'https://example.com/users',
+            protocol: 'https:',
+            hostname: 'example.com',
+            username: '',
+            password: '',
+            host: 'example.com',
+            port: '',
+            path: '/users',
+            search: '',
+            hash: '',
+        },
+    },
+    {
+        label: 'parses root url',
+        input: 'https://example.com',
+        expected: {
+            href: 'https://example.com/',
+            protocol: 'https:',
+            hostname: 'example.com',
+            username: '',
+            password: '',
+            host: 'example.com',
+            port: '',
+            path: '/',
+            search: '',
+            hash: '',
+        },
+    },
+    {
+        label: 'parses relative path',
+        input: '/users?page=5',
+        expected: {
+            href: 'fake://fake/users?page=5',
+            protocol: 'fake:',
+            hostname: 'fake',
+            username: '',
+            password: '',
+            host: 'fake',
+            port: '',
+            path: '/users',
+            search: '?page=5',
+            hash: '',
+        },
+    },
+    {
+        label: 'parses hash',
+        input: 'https://example.com/docs#intro',
+        expected: {
+            href: 'https://example.com/docs#intro',
+            protocol: 'https:',
+            hostname: 'example.com',
+            username: '',
+            password: '',
+            host: 'example.com',
+            port: '',
+            path: '/docs',
+            search: '',
+            hash: '#intro',
+        },
+    },
+    {
+        label: 'parses query string',
+        input: 'https://example.com?a=1&b=2',
+        expected: {
+            href: 'https://example.com/?a=1&b=2',
+            protocol: 'https:',
+            hostname: 'example.com',
+            username: '',
+            password: '',
+            host: 'example.com',
+            port: '',
+            path: '/',
+            search: '?a=1&b=2',
+            hash: '',
+        },
+    },
+    {
+        label: 'parses localhost with port',
+        input: 'http://localhost:3000/foo',
+        expected: {
+            href: 'http://localhost:3000/foo',
+            protocol: 'http:',
+            hostname: 'localhost',
+            username: '',
+            password: '',
+            host: 'localhost:3000',
+            port: '3000',
+            path: '/foo',
+            search: '',
+            hash: '',
+        },
+    },
+    {
+        label: 'parses ftp url',
+        input: 'ftp://example.com/file.txt',
+        expected: {
+            href: 'ftp://example.com/file.txt',
+            protocol: 'ftp:',
+            hostname: 'example.com',
+            username: '',
+            password: '',
+            host: 'example.com',
+            port: '',
+            path: '/file.txt',
+            search: '',
+            hash: '',
+        },
+    },
+];
+
+describe('urlparts', function () {
+    it('no args', function () {
+        assert.deepStrictEqual(urlparts(), {
+            href: 'fake://fake/',
+            protocol: 'fake:',
+            hostname: 'fake',
+            username: '',
+            password: '',
+            host: 'fake',
+            port: '',
+            path: '/',
+            search: '',
+            hash: '',
+        });
+    });
+
+    describe('happy paths', function () {
+        for (const item of happy_paths) {
+            it(item.label, function () {
+                const actual = urlparts(item.input);
+                assert.deepStrictEqual(actual, item.expected);
+            });
+        }
+    });
+
+    describe('edge values', function () {
+        for (const item of [...edge_values, ...extra_edge_values]) {
+            it(item.label, function () {
+                if (typeof item.value === 'string') {
+                    const tmp = new URL(item.value, 'fake://fake/');
+                    assert.deepStrictEqual(urlparts(item.value), {
+                        href: tmp.href,
+                        protocol: tmp.protocol,
+                        hostname: tmp.hostname,
+                        username: tmp.username,
+                        password: tmp.password,
+                        host: tmp.host,
+                        port: tmp.port,
+                        path: tmp.pathname,
+                        search: tmp.search,
+                        hash: tmp.hash,
+                    });
+                }
+                else if (item.value instanceof URL) {
+                    const tmp = item.value;
+                    assert.deepStrictEqual(urlparts(item.value), {
+                        href: tmp.href,
+                        protocol: tmp.protocol,
+                        hostname: tmp.hostname,
+                        username: tmp.username,
+                        password: tmp.password,
+                        host: tmp.host,
+                        port: tmp.port,
+                        path: tmp.pathname,
+                        search: tmp.search,
+                        hash: tmp.hash,
+                    });
+                }
+                else {
+                    assert.deepStrictEqual(urlparts(item.value), {
+                        href: 'fake://fake/',
+                        protocol: 'fake:',
+                        hostname: 'fake',
+                        username: '',
+                        password: '',
+                        host: 'fake',
+                        port: '',
+                        path: '/',
+                        search: '',
+                        hash: '',
+                    });
+                }
+            });
+        }
+    });
+});