@koine/utils 2.0.0-beta.13 → 2.0.0-beta.15

package/matchSorter.js

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

package/mbToBytes.d.ts

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

package/mbToBytes.js

@@ -0,0 +1,2 @@
+export var mbToBytes = function (bytes) { return bytes * 1000 * 1000; };
+export default mbToBytes;

package/mergeObjects.d.ts

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

package/mergeObjects.js

@@ -0,0 +1,33 @@
+import { __spreadArray } from "tslib";
+import { isObject } from "./isObject.js";
+import { isUndefined } from "./isUndefined.js";
+export var mergeObjects = function (target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    if (!sources.length) {
+        return target;
+    }
+    var source = sources.shift();
+    if (source === undefined) {
+        return target;
+    }
+    if (isObject(target) && isObject(source)) {
+        Object.keys(source).forEach(function (_key) {
+            var 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.apply(void 0, __spreadArray([target], sources, false));
+};

package/mergeUrlQueryParams.d.ts

@@ -1,8 +1,3 @@
-import { type AnyQueryParams } from "./location";
-/**
- * Merge query parameters objects, it *mutates* the first given object argument
- *
- * @category location
- */
+import { type AnyQueryParams } from "./location.js";
 export declare function mergeUrlQueryParams<T extends AnyQueryParams>(oldParams?: NonNullable<AnyQueryParams>, newParams?: NonNullable<AnyQueryParams>): T;
 export default mergeUrlQueryParams;

package/mergeUrlQueryParams.js

@@ -0,0 +1,16 @@
+import isNull from "./isNull.js";
+export function mergeUrlQueryParams(oldParams, newParams) {
+    if (oldParams === void 0) { oldParams = {}; }
+    if (newParams === void 0) { newParams = {}; }
+    for (var key in newParams) {
+        var 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,9 +1,2 @@
-/**
- * Move item from one place to another in a sortable array of objects, re-ordering
- * the array accrodingly (no swapping of position).
- * This is useful for drag and drop functionalities
- *
- * @category array
- */
 export declare function 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,10 @@
+import { __spreadArray } from "tslib";
+export function moveSortableArrayItemByKey(items, key, fromItem, toItem) {
+    var itemsKeys = items.map(function (item) { return item[key]; });
+    var idxFrom = itemsKeys.indexOf(fromItem[key]);
+    var idxTo = itemsKeys.indexOf(toItem[key]);
+    var item = items.splice(idxFrom, 1)[0];
+    items.splice(idxTo, 0, item);
+    return __spreadArray([], items, true);
+}
+export default moveSortableArrayItemByKey;

package/noop.d.ts

@@ -1,7 +1,2 @@
-/**
- * No operation function
- *
- * @category native
- */
 export declare const noop: () => void | undefined;
 export default noop;

package/noop.js

@@ -0,0 +1,2 @@
+export var noop = function () { return void 0; };
+export default noop;

package/normaliseUrl.d.ts

@@ -1,11 +1,2 @@
-/**
- * Normalise URL, it works both for absolute and relative URLs
- *
- * - replaces too many consecutive slashes (except `http{s}://`)
- * - removes the trailing slash
- *
- * @category location
- * @see https://stackoverflow.com/a/40649435/1938970
- */
 export declare function normaliseUrl(absoluteUrl?: string): string;
 export default normaliseUrl;

package/normaliseUrl.js

@@ -0,0 +1,6 @@
+import removeTralingSlash from "./removeTrailingSlash.js";
+export function normaliseUrl(absoluteUrl) {
+    if (absoluteUrl === void 0) { absoluteUrl = ""; }
+    return removeTralingSlash(absoluteUrl.replace(/(:\/\/)|(\/)+/g, "$1$2"));
+}
+export default normaliseUrl;

package/normaliseUrlPathname.d.ts

@@ -1,10 +1,2 @@
-/**
- * Normalise URL pathname (relative URL)
- *
- * - replaces too many consecutive slashes
- * - removes the trailing slash
- *
- * @category location
- */
 export declare function normaliseUrlPathname(pathname?: string): string;
 export default normaliseUrlPathname;

package/normaliseUrlPathname.js

@@ -0,0 +1,6 @@
+import removeTralingSlash from "./removeTrailingSlash.js";
+export function normaliseUrlPathname(pathname) {
+    if (pathname === void 0) { pathname = ""; }
+    return removeTralingSlash(pathname.replace(/\/+/g, "/"));
+}
+export default normaliseUrlPathname;

package/objectOmit.d.ts

@@ -1,11 +1,2 @@
-/**
- * Omit object properties by removing the given keys, it returns a
- * new object.
- *
- * NOTE: most of the time using a normal [destructuring assignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) is enough,
- * use this utility only when it makes sense.
- *
- * @category object
- */
 export declare function 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,10 @@
+export function objectOmit(object, keys) {
+    return Object.keys(object).reduce(function (output, key) {
+        if (!keys.includes(key)) {
+            output[key] =
+                object[key];
+        }
+        return output;
+    }, {});
+}
+export default objectOmit;

package/objectPick.d.ts

@@ -1,8 +1,2 @@
-/**
- * Pick object properties by selecting only the given keys, it returns a
- * new object.
- *
- * @category object
- */
 export declare function 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 function objectPick(object, keys) {
+    var output = {};
+    var len = keys.length;
+    while (len--) {
+        output[keys[len]] = object[keys[len]];
+    }
+    return output;
+}
+export default objectPick;