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

package/matchSorter.js

@@ -0,0 +1,238 @@
+import { isString } from "./isString";
+import { removeAccents } from "./removeAccents";
+const RANKING_CASE_SENSITIVE_EQUAL = 7;
+const RANKING_EQUAL = 6;
+const RANKING_STARTS_WITH = 5;
+const RANKING_WORD_STARTS_WITH = 4;
+const RANKING_CONTAINS = 3;
+const RANKING_ACRONYM = 2;
+const RANKING_MATCHES = 1;
+const RANKING_NO_MATCH = 0;
+let defaultBaseSortFn = (a, b) => String(a.rankedValue).localeCompare(String(b.rankedValue));
+let matchSorter = (items, value, options = {}) => {
+    const { keys, threshold = RANKING_MATCHES, baseSort = defaultBaseSortFn, sorter = (matchedItems) => matchedItems.sort((a, b) => sortRankedValues(a, b, baseSort)), } = options;
+    const matchedItems = items.reduce(reduceItemsToRanked, []);
+    return sorter(matchedItems).map(({ item }) => item);
+    function reduceItemsToRanked(matches, item, index) {
+        const rankingInfo = getHighestRanking(item, keys, value, options);
+        const { rank, keyThreshold = threshold } = rankingInfo;
+        if (rank >= keyThreshold) {
+            matches.push({ ...rankingInfo, item, index });
+        }
+        return matches;
+    }
+};
+let getHighestRanking = (item, keys, value, options) => {
+    if (!keys) {
+        const stringItem = item;
+        return {
+            rankedValue: stringItem,
+            rank: getMatchRanking(stringItem, value, options),
+            keyIndex: -1,
+            keyThreshold: options.threshold,
+        };
+    }
+    const valuesToRank = getAllValuesToRank(item, keys);
+    return valuesToRank.reduce(({ rank, rankedValue, keyIndex, keyThreshold }, { itemValue, attributes }, i) => {
+        let newRank = getMatchRanking(itemValue, value, options);
+        let newRankedValue = rankedValue;
+        const { minRanking, maxRanking, threshold } = attributes;
+        if (newRank < minRanking && newRank >= RANKING_MATCHES) {
+            newRank = minRanking;
+        }
+        else if (newRank > maxRanking) {
+            newRank = maxRanking;
+        }
+        if (newRank > rank) {
+            rank = newRank;
+            keyIndex = i;
+            keyThreshold = threshold;
+            newRankedValue = itemValue;
+        }
+        return { rankedValue: newRankedValue, rank, keyIndex, keyThreshold };
+    }, {
+        rankedValue: item,
+        rank: RANKING_NO_MATCH,
+        keyIndex: -1,
+        keyThreshold: options.threshold,
+    });
+};
+let getMatchRanking = (testString, stringToRank, options) => {
+    testString = prepareValueForComparison(testString, options);
+    stringToRank = prepareValueForComparison(stringToRank, options);
+    if (stringToRank.length > testString.length) {
+        return RANKING_NO_MATCH;
+    }
+    if (testString === stringToRank) {
+        return RANKING_CASE_SENSITIVE_EQUAL;
+    }
+    testString = testString.toLowerCase();
+    stringToRank = stringToRank.toLowerCase();
+    if (testString === stringToRank) {
+        return RANKING_EQUAL;
+    }
+    if (testString.startsWith(stringToRank)) {
+        return RANKING_STARTS_WITH;
+    }
+    if (testString.includes(` ${stringToRank}`)) {
+        return RANKING_WORD_STARTS_WITH;
+    }
+    if (testString.includes(stringToRank)) {
+        return RANKING_CONTAINS;
+    }
+    else if (stringToRank.length === 1) {
+        return RANKING_NO_MATCH;
+    }
+    if (getAcronym(testString).includes(stringToRank)) {
+        return RANKING_ACRONYM;
+    }
+    return getClosenessRanking(testString, stringToRank);
+};
+let getAcronym = (string) => {
+    let acronym = "";
+    const wordsInString = string.split(" ");
+    wordsInString.forEach((wordInString) => {
+        const splitByHyphenWords = wordInString.split("-");
+        splitByHyphenWords.forEach((splitByHyphenWord) => {
+            acronym += splitByHyphenWord.substring(0, 1);
+        });
+    });
+    return acronym;
+};
+let getClosenessRanking = (testString, stringToRank) => {
+    let matchingInOrderCharCount = 0;
+    let charNumber = 0;
+    function findMatchingCharacter(matchChar, string, index) {
+        for (let j = index, J = string.length; j < J; j++) {
+            const stringChar = string[j];
+            if (stringChar === matchChar) {
+                matchingInOrderCharCount += 1;
+                return j + 1;
+            }
+        }
+        return -1;
+    }
+    function getRanking(spread) {
+        const spreadPercentage = 1 / spread;
+        const inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
+        const ranking = RANKING_MATCHES + inOrderPercentage * spreadPercentage;
+        return ranking;
+    }
+    const firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
+    if (firstIndex < 0) {
+        return RANKING_NO_MATCH;
+    }
+    charNumber = firstIndex;
+    for (let i = 1, I = stringToRank.length; i < I; i++) {
+        const matchChar = stringToRank[i];
+        charNumber = findMatchingCharacter(matchChar, testString, charNumber);
+        const found = charNumber > -1;
+        if (!found) {
+            return RANKING_NO_MATCH;
+        }
+    }
+    const spread = charNumber - firstIndex;
+    return getRanking(spread);
+};
+let sortRankedValues = (a, b, baseSort) => {
+    const aFirst = -1;
+    const bFirst = 1;
+    const { rank: aRank, keyIndex: aKeyIndex } = a;
+    const { rank: bRank, keyIndex: bKeyIndex } = b;
+    const same = aRank === bRank;
+    if (same) {
+        if (aKeyIndex === bKeyIndex) {
+            return baseSort(a, b);
+        }
+        else {
+            return aKeyIndex < bKeyIndex ? aFirst : bFirst;
+        }
+    }
+    else {
+        return aRank > bRank ? aFirst : bFirst;
+    }
+};
+let prepareValueForComparison = (value, { keepDiacritics }) => {
+    value = `${value}`;
+    if (!keepDiacritics) {
+        value = removeAccents(value);
+    }
+    return value;
+};
+let getItemValues = (item, key) => {
+    if (typeof key === "object") {
+        key = key.key;
+    }
+    let value;
+    if (typeof key === "function") {
+        value = key(item);
+    }
+    else if (item == null) {
+        value = null;
+    }
+    else if (Object.hasOwnProperty.call(item, key)) {
+        value = item[key];
+    }
+    else if (key.includes(".")) {
+        return getNestedValues(key, item);
+    }
+    else {
+        value = null;
+    }
+    if (value == null) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [String(value)];
+};
+let getNestedValues = (path, item) => {
+    const keys = path.split(".");
+    let values = [item];
+    for (let i = 0, I = keys.length; i < I; i++) {
+        const nestedKey = keys[i];
+        let nestedValues = [];
+        for (let j = 0, J = values.length; j < J; j++) {
+            const nestedItem = values[j];
+            if (nestedItem == null)
+                continue;
+            if (Object.hasOwnProperty.call(nestedItem, nestedKey)) {
+                const nestedValue = nestedItem[nestedKey];
+                if (nestedValue != null) {
+                    nestedValues.push(nestedValue);
+                }
+            }
+            else if (nestedKey === "*") {
+                nestedValues = nestedValues.concat(nestedItem);
+            }
+        }
+        values = nestedValues;
+    }
+    if (Array.isArray(values[0])) {
+        const result = [];
+        return result.concat(...values);
+    }
+    return values;
+};
+let getAllValuesToRank = (item, keys) => {
+    const allValues = [];
+    for (let j = 0, J = keys.length; j < J; j++) {
+        const key = keys[j];
+        const attributes = getKeyAttributes(key);
+        const itemValues = getItemValues(item, key);
+        for (let i = 0, I = itemValues.length; i < I; i++) {
+            allValues.push({
+                itemValue: itemValues[i],
+                attributes,
+            });
+        }
+    }
+    return allValues;
+};
+const defaultKeyAttributes = {
+    maxRanking: Infinity,
+    minRanking: -Infinity,
+};
+let getKeyAttributes = (key) => isString(key) ? defaultKeyAttributes : { ...defaultKeyAttributes, ...key };
+export { matchSorter, defaultBaseSortFn };

package/mbToBytes.js

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

package/mergeObjects.js

@@ -0,0 +1,28 @@
+import { isObject } from "./isObject";
+import { isUndefined } from "./isUndefined";
+export let mergeObjects = (target, ...sources) => {
+    if (!sources.length) {
+        return target;
+    }
+    const source = sources.shift();
+    if (source === undefined) {
+        return target;
+    }
+    if (isObject(target) && isObject(source)) {
+        Object.keys(source).forEach((_key) => {
+            const key = _key;
+            if (isObject(source[key])) {
+                if (!target[key]) {
+                    target[key] = {};
+                }
+                mergeObjects(target[key], source[key]);
+            }
+            else {
+                if (!isUndefined(source[key])) {
+                    target[key] = source[key];
+                }
+            }
+        });
+    }
+    return mergeObjects(target, ...sources);
+};

package/mergeUrlQueryParams.js

@@ -0,0 +1,13 @@
+import { isNull } from "./isNull";
+export let mergeUrlQueryParams = (oldParams = {}, newParams = {}) => {
+    for (const key in newParams) {
+        const value = newParams[key];
+        if (oldParams[key] && isNull(value)) {
+            delete oldParams[key];
+        }
+        else {
+            oldParams[key] = value;
+        }
+    }
+    return oldParams;
+};

package/moveSortableArrayItemByKey.js

@@ -0,0 +1,8 @@
+export let moveSortableArrayItemByKey = (items, key, fromItem, toItem) => {
+    const itemsKeys = items.map((item) => item[key]);
+    const idxFrom = itemsKeys.indexOf(fromItem[key]);
+    const idxTo = itemsKeys.indexOf(toItem[key]);
+    const [item] = items.splice(idxFrom, 1);
+    items.splice(idxTo, 0, item);
+    return [...items];
+};

package/noop.js

@@ -0,0 +1 @@
+export let noop = () => void 0;

package/normaliseUrl.js

@@ -0,0 +1,2 @@
+import { removeTralingSlash } from "./removeTrailingSlash";
+export let normaliseUrl = (absoluteUrl = "") => removeTralingSlash(absoluteUrl.replace(/(:\/\/)|(\/)+/g, "$1$2"));

package/normaliseUrlPathname.js

@@ -0,0 +1,2 @@
+import { removeTralingSlash } from "./removeTrailingSlash";
+export let normaliseUrlPathname = (pathname = "") => removeTralingSlash(pathname.replace(/\/+/g, "/"));

package/objectFlat.js

@@ -0,0 +1,16 @@
+export let objectFlat = (obj, delimiter = ".", parent = "") => {
+    return Object.keys(obj).reduce((acc, _key) => {
+        const key = _key;
+        const propName = (parent ? `${parent}${delimiter}${key}` : key);
+        if (typeof obj[key] === "object") {
+            acc = {
+                ...acc,
+                ...objectFlat(obj[key], delimiter, propName),
+            };
+        }
+        else {
+            acc[propName] = obj[key];
+        }
+        return acc;
+    }, {});
+};

package/objectFlip.js

@@ -0,0 +1,4 @@
+export let objectFlip = (input, keyTransformer) => Object.fromEntries(Object.entries(input).map(([key, value]) => [
+    value,
+    keyTransformer ? keyTransformer(key) : key,
+]));

package/objectMergeWithDefaults.js

@@ -0,0 +1,20 @@
+import { isObject } from "./isObject";
+export let objectMergeWithDefaults = (defaults, overrides) => overrides
+    ? Object.keys(overrides).reduce((result, _key) => {
+        const keyDefaults = _key;
+        const keyOverrides = _key;
+        if (isObject(overrides[keyOverrides])) {
+            if (!defaults[keyDefaults]) {
+                defaults[keyDefaults] = {};
+            }
+            result[keyDefaults] = objectMergeWithDefaults(defaults[keyDefaults], overrides[keyOverrides]);
+        }
+        else {
+            result[keyDefaults] =
+                overrides[keyOverrides] === undefined
+                    ? defaults[keyDefaults]
+                    : overrides[keyOverrides];
+        }
+        return result;
+    }, { ...defaults })
+    : defaults;

package/objectOmit.js

@@ -0,0 +1,7 @@
+export let objectOmit = (object, keys) => Object.keys(object).reduce((output, key) => {
+    if (!keys.includes(key)) {
+        output[key] =
+            object[key];
+    }
+    return output;
+}, {});

package/objectPick.js

@@ -0,0 +1,8 @@
+export let objectPick = (object, keys) => {
+    const output = {};
+    let len = keys.length;
+    while (len--) {
+        output[keys[len]] = object[keys[len]];
+    }
+    return output;
+};

package/objectSort.js

@@ -0,0 +1 @@
+export let objectSort = (data, compareFn) => Object.fromEntries(Object.entries(data).sort(compareFn));

package/objectSortByKeysMatching.js

@@ -0,0 +1,2 @@
+import { objectSort } from "./objectSort";
+export let objectSortByKeysMatching = (data, keyMatch) => objectSort(data, ([a], [b]) => (a === keyMatch ? -1 : a.localeCompare(b)));

package/objectToArray.js

@@ -0,0 +1 @@
+export let objectToArray = (obj, iterator) => Object.keys(obj).map(iterator);

package/package.json

@@ -14,5 +14,5 @@
   },
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
-  "version": "2.0.0-beta.72"
+  "version": "2.0.0-beta.73"
 }

package/parseCookie.js

@@ -0,0 +1,32 @@
+let tryDecode = (str, decode) => {
+    try {
+        return decode(str);
+    }
+    catch (e) {
+        return str;
+    }
+};
+export let parseCookie = (str, attributes = {}) => {
+    if (typeof str !== "string") {
+        throw new TypeError("argument str must be a string");
+    }
+    const obj = {};
+    const pairs = str.split(";");
+    const { decode = decodeURIComponent } = attributes;
+    for (let i = 0; i < pairs.length; i++) {
+        const pair = pairs[i];
+        const index = pair.indexOf("=");
+        if (index < 0) {
+            continue;
+        }
+        const key = pair.substring(0, index).trim();
+        if (undefined == obj[key]) {
+            let val = pair.substring(index + 1, pair.length).trim();
+            if (val[0] === '"') {
+                val = val.slice(1, -1);
+            }
+            obj[key] = tryDecode(val, decode);
+        }
+    }
+    return obj;
+};

package/parseURL.js

@@ -0,0 +1,13 @@
+export let parseURL = (url) => {
+    const match = url.match(/^(https?:)\/\/(([^:/?#]*)(?::([0-9]+))?)([/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/);
+    return (match && {
+        href: url,
+        protocol: match[1],
+        host: match[2],
+        hostname: match[3],
+        port: match[4],
+        pathname: match[5],
+        search: match[6],
+        hash: match[7],
+    });
+};

package/quaranteneProps.js

@@ -0,0 +1,15 @@
+export let quaranteneProps = (props, propsKeysToQuarantene) => {
+    const healthyProps = {
+        _: {},
+    };
+    for (const key in props) {
+        const prop = props[key];
+        if (propsKeysToQuarantene.includes(key)) {
+            healthyProps._[key] = prop;
+        }
+        else {
+            healthyProps[key] = prop;
+        }
+    }
+    return healthyProps;
+};

package/randomInt.js

@@ -0,0 +1 @@
+export let randomInt = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);

package/randomKey.js

@@ -0,0 +1,4 @@
+export let randomKey = (obj) => {
+    const keys = Object.keys(obj);
+    return keys[(keys.length * Math.random()) << 0];
+};

package/readCookie.js

@@ -0,0 +1,33 @@
+let converterRead = (value) => {
+    if (value[0] === '"') {
+        value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+};
+export function readCookie(name) {
+    if (typeof document === "undefined") {
+        if (process.env["NODE_ENV"] === "development") {
+            console.warn("[@koine/utils:readCookie] document is undefined");
+        }
+        return name ? "" : {};
+    }
+    const cookies = document.cookie ? document.cookie.split("; ") : [];
+    const all = {};
+    for (let i = 0; i < cookies.length; i++) {
+        const parts = cookies[i].split("=");
+        const value = parts.slice(1).join("=");
+        try {
+            const found = decodeURIComponent(parts[0]);
+            all[found] = converterRead(value);
+            if (name === found) {
+                break;
+            }
+        }
+        catch (e) {
+            if (process.env["NODE_ENV"] === "development") {
+                console.warn("[@koine/utils:readCookie] failed to decode", value);
+            }
+        }
+    }
+    return name ? all[name] : all;
+}

package/removeAccents.js

@@ -0,0 +1,9 @@
+import { accentsSets } from "./accentSets";
+export let removeAccents = (text = "", sets = accentsSets) => {
+    let len = sets.length;
+    while (len--) {
+        const [to, from] = sets[len];
+        text = text.replace(new RegExp(`[${from}]`, "gi"), to);
+    }
+    return text;
+};

package/removeCookie.js

@@ -0,0 +1,9 @@
+import { defaultAttributesClient } from "./cookie";
+import { setCookie } from "./setCookie";
+export let removeCookie = (name, attributes = {}) => {
+    setCookie(name, "", {
+        ...defaultAttributesClient,
+        ...attributes,
+        expires: -1,
+    });
+};

package/removeDuplicates.js

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

package/removeDuplicatesByKey.js

@@ -0,0 +1,12 @@
+export let removeDuplicatesByKey = (array = [], key) => {
+    const keysMap = {};
+    const output = [];
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        if (!keysMap[item[key]]) {
+            output.push(item);
+            keysMap[item[key]] = true;
+        }
+    }
+    return output;
+};

package/removeDuplicatesComparing.js

@@ -0,0 +1,6 @@
+import { findDuplicatedIndexes } from "./findDuplicatedIndexes";
+import { removeIndexesFromArray } from "./removeIndexesFromArray";
+export let removeDuplicatesComparing = (from, to) => {
+    const indexes = findDuplicatedIndexes(from);
+    return removeIndexesFromArray(to, indexes);
+};

package/removeIndexesFromArray.js

@@ -0,0 +1,9 @@
+export let removeIndexesFromArray = (arr, indexes) => {
+    const output = [];
+    for (let i = 0; i < arr.length; i++) {
+        if (!indexes.hasOwnProperty(i)) {
+            output.push(arr[i]);
+        }
+    }
+    return output;
+};

package/removeTrailingSlash.js

@@ -0,0 +1 @@
+export let removeTralingSlash = (urlLike) => (urlLike || "").replace(/\/*$/, "");

package/removeUrlQueryParams.js

@@ -0,0 +1,13 @@
+import { buildUrlQueryString } from "./buildUrlQueryString";
+import { getUrlQueryParams } from "./getUrlQueryParams";
+export let removeUrlQueryParams = (url, paramsToRemove = []) => {
+    const parts = url.split("?");
+    const allParams = getUrlQueryParams(url);
+    const params = {};
+    for (const key in allParams) {
+        if (!paramsToRemove.includes(key)) {
+            params[key] = allParams[key];
+        }
+    }
+    return parts[0] + buildUrlQueryString(params);
+};