@koine/utils 2.0.0-beta.8 → 2.0.0-beta.80

package/matchSorter.cjs.js

@@ -0,0 +1,248 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isString = require('./isString.cjs.js');
+var removeAccents = require('./removeAccents.cjs.js');
+require('./getType.cjs.js');
+require('./accentSets.cjs.js');
+
+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.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.isString(key) ? defaultKeyAttributes : { ...defaultKeyAttributes, ...key };
+
+exports["default"] = matchSorter;
+exports.defaultBaseSortFn = defaultBaseSortFn;
+exports.matchSorter = matchSorter;

package/matchSorter.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './matchSorter.cjs.js';
+export { _default as default } from './matchSorter.cjs.default.js';

package/matchSorter.d.ts

@@ -47,15 +47,8 @@ declare const RANKING_ACRONYM = 2;
 declare const RANKING_MATCHES = 1;
 declare const RANKING_NO_MATCH = 0;
 type Ranking = typeof RANKING_CASE_SENSITIVE_EQUAL | typeof RANKING_EQUAL | typeof RANKING_STARTS_WITH | typeof RANKING_WORD_STARTS_WITH | typeof RANKING_CONTAINS | typeof RANKING_ACRONYM | typeof RANKING_MATCHES | typeof RANKING_NO_MATCH;
-declare const defaultBaseSortFn: BaseSorter<unknown>;
-/**
- * Takes an array of items and a value and returns a new array with the items that match the given value
- * @param {Array} items - the items to sort
- * @param {String} value - the value to use for ranking
- * @param {Object} options - Some options to configure the sorter
- * @return {Array} - the new sorted array
- */
-declare function matchSorter<ItemType = string>(items: ReadonlyArray<ItemType>, value: string, options?: MatchSorterOptions<ItemType>): Array<ItemType>;
+declare let defaultBaseSortFn: BaseSorter<unknown>;
+declare let matchSorter: <ItemType = string>(items: readonly ItemType[], value: string, options?: MatchSorterOptions<ItemType>) => ItemType[];
 export { matchSorter, defaultBaseSortFn };
 export type { MatchSorterOptions, KeyAttributesOptions, KeyOption, KeyAttributes, RankingInfo, ValueGetterKey, };
 export default matchSorter;

package/matchSorter.esm.js

@@ -0,0 +1,242 @@
+import { isString } from './isString.esm.js';
+import { removeAccents } from './removeAccents.esm.js';
+import './getType.esm.js';
+import './accentSets.esm.js';
+
+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 as default, defaultBaseSortFn, matchSorter };

package/mbToBytes.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./mbToBytes";
+export { default } from "./mbToBytes";

package/mbToBytes.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./mbToBytes.cjs.js').default;

package/mbToBytes.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let mbToBytes = (bytes) => bytes * 1000 * 1000;
+
+exports["default"] = mbToBytes;
+exports.mbToBytes = mbToBytes;

package/mbToBytes.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './mbToBytes.cjs.js';
+export { _default as default } from './mbToBytes.cjs.default.js';

package/mbToBytes.d.ts

@@ -1,7 +1,2 @@
-/**
- * Megabytes to bytes
- *
- * @category format
- */
-export declare const mbToBytes: (bytes: number) => number;
+export declare let mbToBytes: (bytes: number) => number;
 export default mbToBytes;

package/mbToBytes.esm.js

@@ -0,0 +1,3 @@
+let mbToBytes = (bytes) => bytes * 1000 * 1000;
+
+export { mbToBytes as default, mbToBytes };

package/mergeObjects.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./mergeObjects";
+export { default } from "./mergeObjects";

package/mergeObjects.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./mergeObjects.cjs.js').default;

package/mergeObjects.cjs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isObject = require('./isObject.cjs.js');
+var isUndefined = require('./isUndefined.cjs.js');
+require('./isPlainObject.cjs.js');
+require('./getType.cjs.js');
+
+let mergeObjects = (target, ...sources) => {
+    if (!sources.length) {
+        return target;
+    }
+    const source = sources.shift();
+    if (source === undefined) {
+        return target;
+    }
+    if (isObject.isObject(target) && isObject.isObject(source)) {
+        Object.keys(source).forEach((_key) => {
+            const key = _key;
+            if (isObject.isObject(source[key])) {
+                if (!target[key]) {
+                    target[key] = {};
+                }
+                mergeObjects(target[key], source[key]);
+            }
+            else {
+                if (!isUndefined.isUndefined(source[key])) {
+                    target[key] = source[key];
+                }
+            }
+        });
+    }
+    return mergeObjects(target, ...sources);
+};
+
+exports["default"] = mergeObjects;
+exports.mergeObjects = mergeObjects;

package/mergeObjects.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './mergeObjects.cjs.js';
+export { _default as default } from './mergeObjects.cjs.default.js';

package/mergeObjects.d.ts

@@ -1,7 +1,2 @@
-/**
- * Merge two or more objects together. It mutates the target object.
- *
- * @category objects
- * @see https://stackoverflow.com/a/46973278/1938970
- */
-export declare const mergeObjects: <T extends object = object>(target: T, ...sources: Partial<T>[]) => T;
+export declare let mergeObjects: <T extends object = object>(target: T, ...sources: Partial<T>[]) => T;
+export default mergeObjects;

package/mergeObjects.esm.js

@@ -0,0 +1,33 @@
+import { isObject } from './isObject.esm.js';
+import { isUndefined } from './isUndefined.esm.js';
+import './isPlainObject.esm.js';
+import './getType.esm.js';
+
+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 { mergeObjects as default, mergeObjects };

package/mergeUrlQueryParams.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./mergeUrlQueryParams";
+export { default } from "./mergeUrlQueryParams";

package/mergeUrlQueryParams.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./mergeUrlQueryParams.cjs.js').default;

package/mergeUrlQueryParams.cjs.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isNull = require('./isNull.cjs.js');
+require('./getType.cjs.js');
+
+let mergeUrlQueryParams = (oldParams = {}, newParams = {}) => {
+    for (const key in newParams) {
+        const value = newParams[key];
+        if (oldParams[key] && isNull.isNull(value)) {
+            delete oldParams[key];
+        }
+        else {
+            oldParams[key] = value;
+        }
+    }
+    return oldParams;
+};
+
+exports["default"] = mergeUrlQueryParams;
+exports.mergeUrlQueryParams = mergeUrlQueryParams;

package/mergeUrlQueryParams.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './mergeUrlQueryParams.cjs.js';
+export { _default as default } from './mergeUrlQueryParams.cjs.default.js';