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

package/matchSorter.js

@@ -0,0 +1,239 @@
+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 };
+export default matchSorter;

package/mbToBytes.d.ts

@@ -1 +1,2 @@
 export declare let mbToBytes: (bytes: number) => number;
+export default mbToBytes;

package/mbToBytes.js

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

package/mergeObjects.d.ts

@@ -1 +1,2 @@
 export declare let mergeObjects: <T extends object = object>(target: T, ...sources: Partial<T>[]) => T;
+export default mergeObjects;

package/mergeObjects.js

@@ -0,0 +1,29 @@
+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);
+};
+export default mergeObjects;

package/mergeUrlQueryParams.d.ts

@@ -1,2 +1,3 @@
 import type { AnyQueryParams } from "./location";
 export declare let mergeUrlQueryParams: <T extends AnyQueryParams>(oldParams?: NonNullable<AnyQueryParams>, newParams?: NonNullable<AnyQueryParams>) => T;
+export default mergeUrlQueryParams;

package/mergeUrlQueryParams.js

@@ -0,0 +1,14 @@
+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;
+};
+export default mergeUrlQueryParams;

package/moveSortableArrayItemByKey.d.ts

@@ -1 +1,2 @@
 export declare let moveSortableArrayItemByKey: <T, K extends keyof T>(items: T[], key: K, fromItem: Pick<T, K>, toItem: Pick<T, K>) => T[];
+export default moveSortableArrayItemByKey;

package/moveSortableArrayItemByKey.js

@@ -0,0 +1,9 @@
+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];
+};
+export default moveSortableArrayItemByKey;

package/noop.d.ts

@@ -1 +1,2 @@
 export declare let noop: () => void | undefined;
+export default noop;

package/noop.js

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

package/normaliseUrl.d.ts

@@ -1 +1,2 @@
 export declare let normaliseUrl: (absoluteUrl?: string) => string;
+export default normaliseUrl;

package/normaliseUrl.js

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

package/normaliseUrlPathname.d.ts

@@ -1 +1,2 @@
 export declare let normaliseUrlPathname: (pathname?: string) => string;
+export default normaliseUrlPathname;

package/normaliseUrlPathname.js

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

package/objectFlat.d.ts

@@ -1,3 +1,4 @@
 export declare let objectFlat: <TReturn extends {
     [key: string]: unknown;
 }, TInput extends object = object>(obj: TInput, delimiter?: string, parent?: string) => TReturn;
+export default objectFlat;

package/objectFlat.js

@@ -0,0 +1,17 @@
+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;
+    }, {});
+};
+export default objectFlat;

package/objectFlip.d.ts

@@ -1 +1,2 @@
 export declare let objectFlip: <T extends PropertyKey, U extends PropertyKey>(input: Record<T, U>, keyTransformer?: ((key: string) => T) | undefined) => Record<U, T>;
+export default objectFlip;

package/objectFlip.js

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

package/objectMergeWithDefaults.d.ts

@@ -3,3 +3,4 @@ export type ObjectMergeWithDefaults<Defaults, Overrides> = Overrides extends und
     [K in keyof Overrides]-?: Overrides[K] extends undefined ? K extends keyof Defaults ? Defaults[K] : never : K extends keyof Defaults ? ObjectMergeWithDefaults<Defaults[K], Overrides[K]> : Overrides[K];
 } : Overrides;
 export declare let objectMergeWithDefaults: <D extends PlainObject, O extends PlainObject>(defaults: D, overrides?: O | undefined) => ObjectMergeWithDefaults<D, O>;
+export default objectMergeWithDefaults;

package/objectMergeWithDefaults.js

@@ -0,0 +1,21 @@
+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;
+export default objectMergeWithDefaults;

package/objectOmit.d.ts

@@ -1 +1,2 @@
 export declare let objectOmit: <T extends object, Keys extends (keyof T)[]>(object: T, keys: Keys) => Omit<T, Keys[number]>;
+export default objectOmit;

package/objectOmit.js

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

package/objectPick.d.ts

@@ -1 +1,2 @@
 export declare let objectPick: <T extends object, Keys extends (keyof T)[]>(object: T, keys: Keys) => Pick<T, Keys[number]>;
+export default objectPick;

package/objectPick.js

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

package/objectSort.d.ts

@@ -1,3 +1,4 @@
 export declare let objectSort: <T extends object>(data: T, compareFn?: ((a: [Extract<keyof T, string>, T[Extract<keyof T, string>]], b: [Extract<keyof T, string>, T[Extract<keyof T, string>]]) => number) | undefined) => {
     [k: string]: any;
 };
+export default objectSort;

package/objectSort.js

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

package/objectSortByKeysMatching.d.ts

@@ -1,3 +1,4 @@
 export declare let objectSortByKeysMatching: <T extends object>(data: T, keyMatch: keyof T) => {
     [k: string]: any;
 };
+export default objectSortByKeysMatching;

package/objectSortByKeysMatching.js

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

package/objectToArray.d.ts

@@ -1 +1,2 @@
 export declare let objectToArray: <T extends object, R>(obj: T, iterator: (key: keyof T, index: number) => R) => R[];
+export default objectToArray;

package/objectToArray.js

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

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.74"
 }

package/parseCookie.d.ts

@@ -1,2 +1,3 @@
 import type { CookieAttributesServer } from "./cookie";
 export declare let parseCookie: <T extends Record<string, unknown> = Record<string, string>>(str: string, attributes?: CookieAttributesServer) => T;
+export default parseCookie;

package/parseCookie.js

@@ -0,0 +1,33 @@
+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;
+};
+export default parseCookie;

package/parseURL.d.ts

@@ -8,3 +8,4 @@ export declare let parseURL: (url: string) => {
     search: string;
     hash: string;
 } | null;
+export default parseURL;

package/parseURL.js

@@ -0,0 +1,14 @@
+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],
+    });
+};
+export default parseURL;

package/quaranteneProps.d.ts

@@ -4,4 +4,4 @@ export declare let quaranteneProps: <TProps extends Record<never, never>, TSupec
 type QuaranteneProps<TProps extends Record<never, never>> = readonly (keyof {
     [K in keyof TProps]?: TProps[K];
 })[];
-export {};
+export default quaranteneProps;

package/quaranteneProps.js

@@ -0,0 +1,16 @@
+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;
+};
+export default quaranteneProps;

package/randomInt.d.ts

@@ -1 +1,2 @@
 export declare let randomInt: (min: number, max: number) => number;
+export default randomInt;

package/randomInt.js

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

package/randomKey.d.ts

@@ -1 +1,2 @@
 export declare let randomKey: <T extends Record<string | number, unknown>>(obj: T) => keyof T;
+export default randomKey;

package/randomKey.js

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

package/readCookie.d.ts

@@ -1,2 +1,3 @@
 export declare function readCookie<T extends Record<string, unknown> = Record<string, string>>(name?: null): T;
 export declare function readCookie<T extends Record<string, unknown> = Record<string, string>, N extends keyof T = keyof T>(name: N): T[N];
+export default readCookie;

package/readCookie.js

@@ -0,0 +1,34 @@
+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;
+}
+export default readCookie;

package/removeAccents.d.ts

@@ -1,2 +1,3 @@
 import type { AccentsSet } from "./accentSets";
 export declare let removeAccents: (text?: string, sets?: AccentsSet[]) => string;
+export default removeAccents;

package/removeAccents.js

@@ -0,0 +1,10 @@
+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;
+};
+export default removeAccents;

package/removeCookie.d.ts

@@ -1,2 +1,3 @@
 import { type CookieAttributesClient } from "./cookie";
 export declare let removeCookie: (name: string, attributes?: CookieAttributesClient) => void;
+export default removeCookie;

package/removeCookie.js

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