@koine/utils 2.0.0-beta.72 → 2.0.0-beta.73

package/Defer.js

@@ -0,0 +1,10 @@
+export function Defer() {
+    const self = this || {};
+    const p = (self.promise = new Promise((resolve, reject) => {
+        self.resolve = resolve;
+        self.reject = reject;
+    }));
+    self.then = p.then.bind(p);
+    self.catch = p.catch.bind(p);
+    return self;
+}

package/Emitter.js

@@ -0,0 +1,19 @@
+export let Emitter = (namespace) => {
+    const all = new Map();
+    return {
+        on(name, handler) {
+            const handlers = all.get(`${namespace}.${String(name)}`);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                all.set(`${namespace}.${String(name)}`, [handler]);
+            }
+        },
+        emit(name, data) {
+            (all.get(`${namespace}.${String(name)}`) || [])
+                .slice()
+                .map((handler) => {
+                handler(data);
+            });
+        },
+    };
+};

package/accentSets.js

@@ -0,0 +1,29 @@
+export let accentsSets = [
+    ["a", "ÀÁÂÃÅÆĀĂĄẠẢẤẦẨẪẬẮẰẲẴẶ"],
+    ["ae", "Ä"],
+    ["c", "ÇĆĈČ"],
+    ["d", "ÐĎĐÞ"],
+    ["e", "ÈÉÊËĒĔĖĘĚẸẺẼẾỀỂỄỆ"],
+    ["g", "ĜĞĢǴ"],
+    ["h", "ĤḦ"],
+    ["i", "ÌÍÎÏĨĪĮİỈỊ"],
+    ["j", "Ĵ"],
+    ["ij", "IJ"],
+    ["k", "Ķ"],
+    ["l", "ĹĻĽŁ"],
+    ["m", "Ḿ"],
+    ["n", "ÑŃŅŇ"],
+    ["o", "ÒÓÔÕØŌŎŐỌỎỐỒỔỖỘỚỜỞỠỢǪǬƠ"],
+    ["oe", "΅"],
+    ["p", "ṕ"],
+    ["r", "ŔŖŘ"],
+    ["s", "ŚŜŞŠ"],
+    ["ss", "ß"],
+    ["t", "ŢŤ"],
+    ["u", "ÙÚÛŨŪŬŮŰŲỤỦỨỪỬỮỰƯ"],
+    ["ue", "Ü"],
+    ["w", "ẂŴẀẄ"],
+    ["x", "ẍ"],
+    ["y", "ÝŶŸỲỴỶỸ"],
+    ["z", "ŹŻŽ"],
+];

package/addOrReplaceAtIdx.js

@@ -0,0 +1,14 @@
+export let addOrReplaceAtIdx = (list, newItem, newIdx) => {
+    if (list.length === 0) {
+        return [newItem];
+    }
+    if (typeof newIdx === "undefined" || list.length - 1 < newIdx) {
+        return [...list, newItem];
+    }
+    return list.map((item, idx) => {
+        if (idx === newIdx) {
+            return newItem;
+        }
+        return item;
+    });
+};

package/areEqual.js

@@ -0,0 +1,45 @@
+import { isArray } from "./isArray";
+import { isObject } from "./isObject";
+let areEqualArrays = (a, b) => {
+    if (!b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!areEqual(a[i], b[i]))
+            return false;
+    }
+    return true;
+};
+let areEqualObjects = (a, b) => {
+    if (!b)
+        return false;
+    const aKeys = Object.keys(a);
+    for (const _key of aKeys) {
+        const key = _key;
+        if (!areEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+};
+export let areEqual = (a, b) => {
+    if (!a && !b) {
+        return true;
+    }
+    if (!b && a !== b) {
+        return false;
+    }
+    const areObjects = isObject(a) && isObject(b);
+    if (areObjects && !areEqualObjects(a, b)) {
+        return false;
+    }
+    const areArrays = isArray(a) && isArray(b);
+    if (areArrays && !areEqualArrays(a, b)) {
+        return false;
+    }
+    if (!areObjects && !areArrays && a !== b) {
+        return false;
+    }
+    return true;
+};

package/arrayFilterFalsy.js

@@ -0,0 +1 @@
+export let arrayFilterFalsy = (list) => (list ? list.filter((r) => !!r) : []);

package/arrayFindLastIndex.js

@@ -0,0 +1,8 @@
+export let arrayFindLastIndex = (array, predicate) => {
+    let l = array.length;
+    while (l--) {
+        if (predicate(array[l], l, array))
+            return l;
+    }
+    return -1;
+};

package/arrayOfAll.js

@@ -0,0 +1 @@
+export let arrayOfAll = () => (array) => array;

package/arraySum.js

@@ -0,0 +1 @@
+export let arraySum = (numbers) => numbers.reduce((sum, current) => sum + current, 0);

package/arrayToLookup.js

@@ -0,0 +1,4 @@
+export let arrayToLookup = (array = []) => array.reduce((obj, item) => {
+    obj[item] = 1;
+    return obj;
+}, {});

package/arrayUniqueByProperties.js

@@ -0,0 +1 @@
+export let arrayUniqueByProperties = (array, keys) => array.filter((item, idx, arr) => arr.findIndex((itemWith) => keys.every((k) => itemWith[k] === item[k])) === idx);

package/buildUrlQueryString.js

@@ -0,0 +1,20 @@
+import { isArray } from "./isArray";
+import { isNull } from "./isNull";
+import { isUndefined } from "./isUndefined";
+export let buildUrlQueryString = (params) => {
+    let output = "";
+    if (!params)
+        return output;
+    for (const key in params) {
+        const value = params[key];
+        if (isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                output += `${key}=${encodeURIComponent(value[i] + "")}&`;
+            }
+        }
+        else if (!isNull(value) && !isUndefined(value)) {
+            output += `${key}=${encodeURIComponent(value + "")}&`;
+        }
+    }
+    return output ? `?${output.replace(/&+$/, "")}` : "";
+};

package/capitalize.js

@@ -0,0 +1,2 @@
+export let capitalize = (string) => ((string || "").charAt(0).toUpperCase() +
+    (string || "").slice(1));

package/changeCaseCamel.js

@@ -0,0 +1,18 @@
+import { capitalCaseTransformFactory, lowerFactory, pascalCaseTransformFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseCamel = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters
+        ? capitalCaseTransformFactory(lower, upper)
+        : pascalCaseTransformFactory(lower, upper);
+    return (prefix +
+        words
+            .map((word, index) => {
+            if (index === 0)
+                return lower(word);
+            return transform(word, index);
+        })
+            .join(options?.delimiter ?? "") +
+        suffix);
+};

package/changeCaseCapital.js

@@ -0,0 +1,11 @@
+import { capitalCaseTransformFactory, lowerFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseCapital = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return (prefix +
+        words
+            .map(capitalCaseTransformFactory(lower, upper))
+            .join(options?.delimiter ?? " ") +
+        suffix);
+};

package/changeCaseConstant.js

@@ -0,0 +1,7 @@
+import { splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseConstant = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return (prefix +
+        words.map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") +
+        suffix);
+};

package/changeCaseDot.js

@@ -0,0 +1,2 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCaseDot = (input, options) => changeCaseNone(input, { delimiter: ".", ...options });

package/changeCaseHelpers.d.ts

@@ -12,8 +12,3 @@ export interface Options {
 }
 export declare let split: (value: string) => string[];
 export declare let splitSeparateNumbers: (value: string) => string[];
-export declare let lowerFactory: (locale: Locale) => (input: string) => string;
-export declare let upperFactory: (locale: Locale) => (input: string) => string;
-export declare let capitalCaseTransformFactory: (lower: (input: string) => string, upper: (input: string) => string) => (word: string) => string;
-export declare let pascalCaseTransformFactory: (lower: (input: string) => string, upper: (input: string) => string) => (word: string, index: number) => string;
-export declare let splitPrefixSuffix: (input: string, options?: Options) => [string, string[], string];

package/changeCaseHelpers.js

@@ -0,0 +1,71 @@
+let SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+let SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+let SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+let DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+let SPLIT_REPLACE_VALUE = "$1\0$2";
+let DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+export let split = (value) => {
+    let result = value.trim();
+    result = result
+        .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)
+        .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+    let start = 0;
+    let end = result.length;
+    while (result.charAt(start) === "\0")
+        start++;
+    if (start === end)
+        return [];
+    while (result.charAt(end - 1) === "\0")
+        end--;
+    return result.slice(start, end).split(/\0/g);
+};
+export let splitSeparateNumbers = (value) => {
+    const words = split(value);
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+        if (match) {
+            const offset = match.index + (match[1] ?? match[2]).length;
+            words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+        }
+    }
+    return words;
+};
+export let lowerFactory = (locale) => locale === false
+    ? (input) => input.toLowerCase()
+    : (input) => input.toLocaleLowerCase(locale);
+export let upperFactory = (locale) => locale === false
+    ? (input) => input.toUpperCase()
+    : (input) => input.toLocaleUpperCase(locale);
+export let capitalCaseTransformFactory = (lower, upper) => (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+export let pascalCaseTransformFactory = (lower, upper) => (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+};
+export let splitPrefixSuffix = (input, options = {}) => {
+    const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+    const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    let prefixIndex = 0;
+    let suffixIndex = input.length;
+    while (prefixIndex < input.length) {
+        const char = input.charAt(prefixIndex);
+        if (!prefixCharacters.includes(char))
+            break;
+        prefixIndex++;
+    }
+    while (suffixIndex > prefixIndex) {
+        const index = suffixIndex - 1;
+        const char = input.charAt(index);
+        if (!suffixCharacters.includes(char))
+            break;
+        suffixIndex = index;
+    }
+    return [
+        input.slice(0, prefixIndex),
+        splitFn(input.slice(prefixIndex, suffixIndex)),
+        input.slice(suffixIndex),
+    ];
+};

package/changeCaseKebab.js

@@ -0,0 +1,2 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCaseKebab = (input, options) => changeCaseNone(input, { delimiter: "-", ...options });

package/changeCaseNone.js

@@ -0,0 +1,7 @@
+import { lowerFactory, splitPrefixSuffix, } from "./changeCaseHelpers";
+export let changeCaseNone = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return (prefix +
+        words.map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") +
+        suffix);
+};

package/changeCasePascal.js

@@ -0,0 +1,10 @@
+import { capitalCaseTransformFactory, lowerFactory, pascalCaseTransformFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCasePascal = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters
+        ? capitalCaseTransformFactory(lower, upper)
+        : pascalCaseTransformFactory(lower, upper);
+    return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+};

package/changeCasePascalSnake.js

@@ -0,0 +1,2 @@
+import { changeCaseCapital } from "./changeCaseCapital";
+export let changeCasePascalSnake = (input, options) => changeCaseCapital(input, { delimiter: "_", ...options });

package/changeCasePath.js

@@ -0,0 +1,2 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCasePath = (input, options) => changeCaseNone(input, { delimiter: "/", ...options });

package/changeCaseSentence.js

@@ -0,0 +1,16 @@
+import { capitalCaseTransformFactory, lowerFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseSentence = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = capitalCaseTransformFactory(lower, upper);
+    return (prefix +
+        words
+            .map((word, index) => {
+            if (index === 0)
+                return transform(word);
+            return lower(word);
+        })
+            .join(options?.delimiter ?? " ") +
+        suffix);
+};

package/changeCaseSnake.js

@@ -0,0 +1,2 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCaseSnake = (input, options) => changeCaseNone(input, { delimiter: "_", ...options });

package/changeCaseTrain.js

@@ -0,0 +1,2 @@
+import { changeCaseCapital } from "./changeCaseCapital";
+export let changeCaseTrain = (input, options) => changeCaseCapital(input, { delimiter: "-", ...options });

package/chunkByChunks.js

@@ -0,0 +1,31 @@
+export let chunkByChunks = (arr, nrOfChunks, balanced) => {
+    if (nrOfChunks < 2)
+        return [arr];
+    const len = arr.length;
+    const output = [];
+    let i = 0;
+    let size;
+    if (len % nrOfChunks === 0) {
+        size = Math.floor(len / nrOfChunks);
+        while (i < len) {
+            output.push(arr.slice(i, (i += size)));
+        }
+    }
+    else if (balanced) {
+        while (i < len) {
+            size = Math.ceil((len - i) / nrOfChunks--);
+            output.push(arr.slice(i, (i += size)));
+        }
+    }
+    else {
+        nrOfChunks--;
+        size = Math.floor(len / nrOfChunks);
+        if (len % size === 0)
+            size--;
+        while (i < size * nrOfChunks) {
+            output.push(arr.slice(i, (i += size)));
+        }
+        output.push(arr.slice(size * nrOfChunks));
+    }
+    return output;
+};

package/chunkBySize.js

@@ -0,0 +1,7 @@
+export let chunkBySize = (arr, size) => {
+    const output = [];
+    for (let i = 0; i < arr.length; i += size) {
+        output.push(arr.slice(i, i + size));
+    }
+    return output;
+};

package/clamp.js

@@ -0,0 +1 @@
+export let clamp = (num, min, max) => Math.min(Math.max(num, min), max);

package/clsx.js

@@ -0,0 +1,39 @@
+let toVal = (mix) => {
+    let k, y, str = "";
+    if (typeof mix === "string" || typeof mix === "number") {
+        str += mix;
+    }
+    else if (typeof mix === "object") {
+        if (Array.isArray(mix)) {
+            for (k = 0; k < mix.length; k++) {
+                if (mix[k]) {
+                    if ((y = toVal(mix[k]))) {
+                        str && (str += " ");
+                        str += y;
+                    }
+                }
+            }
+        }
+        else {
+            for (k in mix) {
+                if (mix[k]) {
+                    str && (str += " ");
+                    str += k;
+                }
+            }
+        }
+    }
+    return str;
+};
+export let clsx = function () {
+    let i = 0, tmp, x, str = "";
+    while (i < arguments.length) {
+        if ((tmp = arguments[i++])) {
+            if ((x = toVal(tmp))) {
+                str && (str += " ");
+                str += x;
+            }
+        }
+    }
+    return str;
+};

package/convertRange.js

@@ -0,0 +1 @@
+export let convertRange = (num, r1, r2) => ((num - r1[0]) * (r2[1] - r2[0])) / (r1[1] - r1[0]) + r2[0];

package/cookie.js

@@ -0,0 +1 @@
+export let defaultAttributesClient = { path: "/" };

package/createPalette.js

@@ -0,0 +1,11 @@
+export let createPalette = (name, shades) => {
+    const map = shades.reduce((map, def) => {
+        map[def[0]] = def[1];
+        return map;
+    }, {});
+    const tailwindPalette = shades.reduce((map, def) => {
+        map[`${name}-${def[0]}`] = def[1];
+        return map;
+    }, {});
+    return [map, tailwindPalette, Object.values(map)];
+};

package/debounce.js

@@ -0,0 +1,17 @@
+export let debounce = (fn, wait, immediate) => {
+    let timeout;
+    return function (...args) {
+        const context = this;
+        const later = function () {
+            timeout = null;
+            if (!immediate)
+                fn.apply(context, args);
+        };
+        const callNow = immediate && !timeout;
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+        if (callNow)
+            fn.apply(context, args);
+    };
+};

package/debouncePromise.js

@@ -0,0 +1,51 @@
+export let debouncePromise = (func, waitMilliseconds = 50, options = {}) => {
+    let timeoutId;
+    const isImmediate = options.isImmediate ?? false;
+    const callback = options.callback ?? false;
+    const maxWait = options.maxWait;
+    let lastInvokeTime = Date.now();
+    let promises = [];
+    function nextInvokeTimeout() {
+        if (maxWait !== undefined) {
+            const timeSinceLastInvocation = Date.now() - lastInvokeTime;
+            if (timeSinceLastInvocation + waitMilliseconds >= maxWait) {
+                return maxWait - timeSinceLastInvocation;
+            }
+        }
+        return waitMilliseconds;
+    }
+    const debouncedFunction = function (...args) {
+        const context = this;
+        return new Promise((resolve, reject) => {
+            const invokeFunction = function () {
+                timeoutId = undefined;
+                lastInvokeTime = Date.now();
+                if (!isImmediate) {
+                    const result = func.apply(context, args);
+                    callback && callback(result);
+                    promises.forEach(({ resolve }) => resolve(result));
+                    promises = [];
+                }
+            };
+            const shouldCallNow = isImmediate && timeoutId === undefined;
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+            timeoutId = setTimeout(invokeFunction, nextInvokeTimeout());
+            if (shouldCallNow) {
+                const result = func.apply(context, args);
+                callback && callback(result);
+                return resolve(result);
+            }
+            promises.push({ resolve, reject });
+        });
+    };
+    debouncedFunction.cancel = function (reason) {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+        promises.forEach(({ reject }) => reject(reason));
+        promises = [];
+    };
+    return debouncedFunction;
+};

package/debounceRaf.js

@@ -0,0 +1,12 @@
+export function debounceRaf(fn) {
+    let timeout;
+    return function (...args) {
+        const context = this;
+        if (timeout) {
+            window.cancelAnimationFrame(timeout);
+        }
+        timeout = window.requestAnimationFrame(function () {
+            fn.apply(context, args);
+        });
+    };
+}

package/decode.js

@@ -0,0 +1 @@
+export let decode = (str) => str.replace(/.{3}/g, (c) => String.fromCharCode(parseInt(c, 10)));

package/encode.js

@@ -0,0 +1 @@
+export let encode = (str) => str.replace(/./g, (c) => ("00" + c.charCodeAt(0)).slice(-3));

package/ensureInt.js

@@ -0,0 +1 @@
+export let ensureInt = (input) => typeof input === "string" ? parseInt(input, 10) : Math.round(input);

package/env.js

@@ -0,0 +1 @@
+"use strict";

package/errorToString.js

@@ -0,0 +1,2 @@
+import { isString } from "./isString";
+export let errorToString = (e) => e instanceof Error ? e.message : isString(e) ? e : "";

package/escapeRegExp.js

@@ -0,0 +1 @@
+export let escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/findDuplicatedIndexes.js

@@ -0,0 +1,10 @@
+export let findDuplicatedIndexes = (arr) => {
+    const indexes = {};
+    for (let i = 0; i < arr.length; i++) {
+        const idxInArray = arr.indexOf(arr[i]);
+        if (idxInArray !== i && idxInArray !== -1) {
+            indexes[i] = true;
+        }
+    }
+    return indexes;
+};

package/forin.js

@@ -0,0 +1,5 @@
+export let forin = (object, cb) => {
+    for (const key in object) {
+        cb(key, object[key]);
+    }
+};

package/gbToBytes.js

@@ -0,0 +1 @@
+export let gbToBytes = (bytes) => bytes * 1000 * 1000 * 1000;

package/getEmptyArray.js

@@ -0,0 +1,4 @@
+import { isNumber } from "./isNumber";
+export let getEmptyArray = (length) => Array.from({
+    length: !isNumber(length) ? parseInt(length, 10) : length,
+});

package/getKeys.js

@@ -0,0 +1 @@
+export let getKeys = Object.keys;

package/getMediaQueryWidthResolvers.js

@@ -0,0 +1,41 @@
+export let getMediaQueryWidthResolvers = (customBreakpoints) => {
+    const breakpoints = {
+        xs: 0,
+        ...customBreakpoints,
+    };
+    const sortedBreakpointsNames = Object.keys(breakpoints).map((key) => {
+        const br = key;
+        return [br, breakpoints[br]];
+    })
+        .sort((a, b) => a[1] - b[1])
+        .map((item) => item[0]);
+    const getNextBreakpoint = (breakpoint) => {
+        const index = sortedBreakpointsNames.indexOf(breakpoint);
+        return sortedBreakpointsNames[index + 1];
+    };
+    const min = (br) => `(min-width: ${breakpoints[br]}px)`;
+    const max = (br) => `(max-width: ${breakpoints[br] - 0.02}px)`;
+    const up = min;
+    const down = (br) => {
+        const brNext = getNextBreakpoint(br);
+        return brNext && `(max-width: ${breakpoints[brNext] - 0.02}px)`;
+    };
+    const between = (br1, br2) => {
+        br2 = br2 || getNextBreakpoint(br1);
+        return br2
+            ? `(min-width: ${breakpoints[br1]}px) and (max-width: ${breakpoints[br2] - 0.02}px)`
+            : min(br1);
+    };
+    const only = (br) => {
+        const brNext = getNextBreakpoint(br);
+        return brNext ? between(br, brNext) : min(br);
+    };
+    return {
+        max,
+        min,
+        down,
+        up,
+        between,
+        only,
+    };
+};