@naturalcycles/js-lib 14.277.0 → 15.0.0

package/dist-esm/nanoid.js

@@ -1,57 +0,0 @@
-// Vendored from https://github.com/ai/nanoid/blob/main/index.browser.js
-// All credit to nanoid authors: https://github.com/ai/nanoid
-// Reason for vendoring: (still) cannot import esm, and Nanoid went ESM-only since 4.0
-/// <reference lib="dom" preserve="true" />
-/* eslint-disable no-bitwise */
-// "0-9a-zA-Z-_", same as base64url alphabet
-const urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-export function nanoidBrowser(length = 21) {
-    let id = '';
-    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(length));
-    while (length--) {
-        // Using the bitwise AND operator to "cap" the value of
-        // the random byte from 255 to 63, in that way we can make sure
-        // that the value will be a valid index for the "chars" string.
-        id += urlAlphabet[bytes[length] & 63];
-    }
-    return id;
-}
-const defaultRandomFunction = (bytes) => globalThis.crypto.getRandomValues(new Uint8Array(bytes));
-export function nanoidBrowserCustomAlphabet(alphabet, length = 21) {
-    return customRandom(alphabet, length, defaultRandomFunction);
-}
-function customRandom(alphabet, defaultSize, getRandom) {
-    // First, a bitmask is necessary to generate the ID. The bitmask makes bytes
-    // values closer to the alphabet size. The bitmask calculates the closest
-    // `2^31 - 1` number, which exceeds the alphabet size.
-    // For example, the bitmask for the alphabet size 30 is 31 (00011111).
-    // `Math.clz32` is not used, because it is not available in browsers.
-    const mask = (2 << Math.log2(alphabet.length - 1)) - 1;
-    // Though, the bitmask solution is not perfect since the bytes exceeding
-    // the alphabet size are refused. Therefore, to reliably generate the ID,
-    // the random bytes redundancy has to be satisfied.
-    // Note: every hardware random generator call is performance expensive,
-    // because the system call for entropy collection takes a lot of time.
-    // So, to avoid additional system calls, extra bytes are requested in advance.
-    // Next, a step determines how many random bytes to generate.
-    // The number of random bytes gets decided upon the ID size, mask,
-    // alphabet size, and magic number 1.6 (using 1.6 peaks at performance
-    // according to benchmarks).
-    // `-~f => Math.ceil(f)` if f is a float
-    // `-~i => i + 1` if i is an integer
-    const step = -~((1.6 * mask * defaultSize) / alphabet.length);
-    return (size = defaultSize) => {
-        let id = '';
-        while (true) {
-            const bytes = getRandom(step);
-            // A compact alternative for `for (var i = 0; i < step; i++)`.
-            let j = step;
-            while (j--) {
-                // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
-                id += alphabet[bytes[j] & mask] || '';
-                if (id.length === size)
-                    return id;
-            }
-        }
-    };
-}

package/dist-esm/number/createDeterministicRandom.js

@@ -1,18 +0,0 @@
-/* eslint-disable no-bitwise */
-/**
- * Returns a "deterministic Math.random() function"
- *
- * Based on: https://gist.github.com/mathiasbynens/5670917
- */
-export function _createDeterministicRandom(seed = 0x2f6e2b1) {
-    return () => {
-        // Robert Jenkins’ 32 bit integer hash function
-        seed = (seed + 0x7ed55d16 + (seed << 12)) & 0xffffffff;
-        seed = (seed ^ 0xc761c23c ^ (seed >>> 19)) & 0xffffffff;
-        seed = (seed + 0x165667b1 + (seed << 5)) & 0xffffffff;
-        seed = ((seed + 0xd3a2646c) ^ (seed << 9)) & 0xffffffff;
-        seed = (seed + 0xfd7046c5 + (seed << 3)) & 0xffffffff;
-        seed = (seed ^ 0xb55a4f09 ^ (seed >>> 16)) & 0xffffffff;
-        return (seed & 0xfffffff) / 0x10000000;
-    };
-}

package/dist-esm/number/number.util.js

@@ -1,109 +0,0 @@
-export function _randomInt(minIncl, maxIncl) {
-    return Math.floor(Math.random() * (maxIncl - minIncl + 1) + minIncl);
-}
-/**
- * Returns random item from an array.
- * Should be used on non-empty arrays! (otherwise will return undefined,
- * which is not reflected in the output type)
- */
-export function _randomArrayItem(array) {
-    return array[_randomInt(0, array.length - 1)];
-}
-/**
- * Convenience function to "throttle" some code - run it less often.
- *
- * @example
- *
- * if (_runLessOften(10)) {
- *   // this code will run only 10% of the time
- * }
- */
-export function _runLessOften(percent) {
-    return Math.random() * 100 < percent;
-}
-// todo: _.random to support floats
-/**
- *  _isBetween(-10, 1, 5) // false
- * _isBetween(1, 1, 5) // true
- * _isBetween(3, 1, 5) // true
- * _isBetween(5, 1, 5) // false
- * _isBetween(7, 1, 5) // false
- *
- * Also works with strings:
- * _isBetween('2020-01-03', '2020-01-01', '2020-01-05') // true
- */
-export function _isBetween(x, min, max, incl = '[)') {
-    if (incl === '[)') {
-        return x >= min && x < max;
-    }
-    if (incl === '[]') {
-        return x >= min && x <= max;
-    }
-    if (incl === '(]') {
-        return x > min && x <= max;
-    }
-    return x > min && x < max;
-}
-export function _clamp(x, minIncl, maxIncl) {
-    // eslint-disable-next-line unicorn/prefer-math-min-max
-    return x <= minIncl ? minIncl : x >= maxIncl ? maxIncl : x;
-}
-/**
- * This function exists, because in JS you cannot just .sort() numbers,
- * as .sort() function first maps everything to String.
- *
- * @example
- *
- * _sortNumbers([1, 3, 2])
- * // [1, 2, 3]
- */
-export function _sortNumbers(numbers, mutate = false, dir = 'asc') {
-    const mod = dir === 'desc' ? -1 : 1;
-    return (mutate ? numbers : [...numbers]).sort((a, b) => (a - b) * mod);
-}
-/**
- * Same as .toFixed(), but conveniently casts the output to Number.
- *
- * @example
- *
- * _toFixed(1.2345, 2)
- * // 1.23
- *
- * _toFixed(1.10, 2)
- * // 1.1
- */
-export function _toFixed(n, fractionDigits) {
-    return Number(n.toFixed(fractionDigits));
-}
-/**
- * Same as .toPrecision(), but conveniently casts the output to Number.
- *
- * @example
- *
- * _toPrecision(1634.56, 1)
- * // 2000
- *
- * _toPrecision(1634.56, 2)
- * // 1600
- */
-export function _toPrecision(n, precision) {
-    return Number(n.toPrecision(precision));
-}
-/**
- * @example
- *
- * _round(1634, 1000) // 2000
- * _round(1634, 500) // 1500
- * _round(1634, 100) // 1600
- * _round(1634, 10) // 1630
- * _round(1634, 1) // 1634
- * _round(1634.5678, 0.1) // 1634.6
- * _round(1634.5678, 0.01) // 1634.57
- */
-export function _round(n, precisionUnit) {
-    if (precisionUnit >= 1) {
-        return Math.round(n / precisionUnit) * precisionUnit;
-    }
-    const v = Math.floor(n) + Math.round((n % 1) / precisionUnit) * precisionUnit;
-    return Number(v.toFixed(String(precisionUnit).length - 2)); // '0.
-}

package/dist-esm/object/deepEquals.js

@@ -1,170 +0,0 @@
-// Heavily inspired by https://github.com/epoberezkin/fast-deep-equal
-/**
- Returns true if a and b are deeply equal.
- 
- Equality is checked recursively, with the following rules/caveats:
- - Primitive values are checked with ===
- - NaN === NaN
- - Array length should be the same, and every value should be equal
- - Sets are checked similarly to arrays (but order doesn't matter in Sets)
- - Objects and Maps are checked that all values match. Undefined values are treated the same as absent key (important!)
- - Order of object/Map keys doesn't matter, unlike when comparing JSON.stringify(a) === JSON.stringify(b)
- - Regex are compared by their source and flags
- - Functions are compared by their `.toString`
- - Any object that overrides `.toString()` is compared by that (e.g Function)
- - Any object that overrides `.valueOf()` is compared by that (e.g Date)
- 
- What are the differences between various deep-equality functions?
- There are:
- - _deepEquals
- - _deepJsonEquals
- - _jsonEquals
- 
- _deepEquals uses "common sense" equality.
- It tries to work "as you would expect it to".
- With the important caveat that undefined values are treated the same as absent key.
- So, _deepEquals should be the first choice.
- It's also the most performant of 3.
- 
- _deepJsonEquals uses different logic, that's often not what you expect.
- It should be used to compare objects of how they would look after "passing via JSON.stringify",
- for example when you return it over the API to the Frontend,
- or when you pass it to be saved to the Database.
- If some object has custom .toJSON() implementation - it'll invoke that (similar to JSON.stringify).
- For these cases - it can be better than _deepEquals.
- And it's better than _jsonEquals, because it doesn't fail/depend on object key order.
- 
- _jsonEquals is simply JSON.stringify(a) === JSON.stringify(b).
- It's the simplest implementation, but also the slowest of 3.
- 
- TLDR: _deepEquals should be useful in most of the cases, start there.
- */
-export function _deepEquals(a, b) {
-    if (a === b)
-        return true;
-    if (Number.isNaN(a)) {
-        return Number.isNaN(b);
-    }
-    if (a && b && typeof a === 'object' && typeof b === 'object') {
-        if (a.constructor !== b.constructor)
-            return false;
-        if (Array.isArray(a)) {
-            const length = a.length;
-            if (!Array.isArray(b) || length !== b.length)
-                return false;
-            for (let i = length; i-- !== 0;) {
-                if (!_deepEquals(a[i], b[i]))
-                    return false;
-            }
-            return true;
-        }
-        if (a instanceof Map && b instanceof Map) {
-            for (const key of new Set([...a.keys(), ...b.keys()])) {
-                if (!_deepEquals(a.get(key), b.get(key)))
-                    return false;
-            }
-            return true;
-        }
-        if (a instanceof Set && b instanceof Set) {
-            if (a.size !== b.size)
-                return false;
-            for (const key of a) {
-                if (!b.has(key))
-                    return false;
-            }
-            return true;
-        }
-        if (a.constructor === RegExp) {
-            return a.source === b.source && a.flags === b.flags;
-        }
-        if (a.valueOf !== Object.prototype.valueOf)
-            return a.valueOf() === b.valueOf();
-        if (a.toString !== Object.prototype.toString)
-            return a.toString() === b.toString();
-        for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
-            if (!_deepEquals(a[key], b[key]))
-                return false;
-        }
-        return true;
-    }
-    return a === b;
-}
-/**
- Returns true if a and b are deeply equal.
- 
- Equality is checked in the same way as if both arguments are processed via
- JSON.stringify and JSON.parse:
- - undefined values are removed, undefined values in an array are turned into `null`, etc.
- - Any Regex, Map, Set, Function stringifies to {}.
- - Date stringifies to its IsoDateTimeString representation.
- - Any object that implements toJSON is compared by the output of its toJSON().
- - NaN stringifies to null
- - Order of object keys does not matter, unlike when comparing JSON.stringify(a) === JSON.stringify(b)
- 
- See _deepEquals docs for more details and comparison.
- */
-export function _deepJsonEquals(a, b) {
-    if (a === b)
-        return true;
-    if (Number.isNaN(a)) {
-        ;
-        a = null;
-    }
-    else if (typeof a === 'function') {
-        ;
-        a = undefined;
-    }
-    else if (a && typeof a === 'object') {
-        if (a instanceof Date) {
-            ;
-            a = a.valueOf();
-        }
-        else if ('toJSON' in a) {
-            a = a.toJSON();
-        }
-    }
-    if (Number.isNaN(b)) {
-        ;
-        b = null;
-    }
-    else if (typeof b === 'function') {
-        ;
-        b = undefined;
-    }
-    else if (b && typeof b === 'object') {
-        if (b instanceof Date) {
-            ;
-            b = b.valueOf();
-        }
-        else if ('toJSON' in b) {
-            b = b.toJSON();
-        }
-    }
-    if (a && b && typeof a === 'object' && typeof b === 'object') {
-        if (Array.isArray(a)) {
-            const length = a.length;
-            if (!Array.isArray(b) || length !== b.length)
-                return false;
-            for (let i = length; i-- !== 0;) {
-                if (!_deepJsonEquals(a[i], b[i]))
-                    return false;
-            }
-            return true;
-        }
-        for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
-            if (!_deepJsonEquals(a[key], b[key]))
-                return false;
-        }
-        return true;
-    }
-    return a === b;
-}
-/**
- * Shortcut for JSON.stringify(a) === JSON.stringify(b)
- *
- * Simplest "deep equals" implementation, but also the slowest,
- * and not robust, in the sense that it depends on the order of object keys.
- */
-export function _jsonEquals(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
-}

package/dist-esm/object/map2.js

@@ -1,21 +0,0 @@
-/**
- * Like Map, but serializes to JSON as an object.
- *
- * Fixes the "issue" of stock Map being json-serialized as `{}`.
- *
- * @experimental
- */
-export class Map2 extends Map {
-    /**
-     * Convenience way to create Map2 from object.
-     */
-    static of(obj) {
-        return new Map2(Object.entries(obj));
-    }
-    toObject() {
-        return Object.fromEntries(this);
-    }
-    toJSON() {
-        return Object.fromEntries(this);
-    }
-}