@koine/utils 2.0.0-beta.2 → 2.0.0-beta.4

package/matchSorter.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultBaseSortFn = exports.matchSorter = void 0;
-var tslib_1 = require("tslib");
 /**
  * @file
  *
@@ -17,47 +13,61 @@ var tslib_1 = require("tslib");
  * @license MIT license.
  * @copyright (c) 2020 Kent C. Dodds
  * @author Kent C. Dodds <me@kentcdodds.com> (https://kentcdodds.com)
- */
-var removeAccents_1 = tslib_1.__importDefault(require("./removeAccents"));
-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));
-};
-exports.defaultBaseSortFn = defaultBaseSortFn;
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    matchSorter: function() {
+        return matchSorter;
+    },
+    defaultBaseSortFn: function() {
+        return defaultBaseSortFn;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _removeAccents = /*#__PURE__*/ _interop_require_default._(require("./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;
+const defaultBaseSortFn = (a, b)=>String(a.rankedValue).localeCompare(String(b.rankedValue));
 /**
  * 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
- */
-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 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) {
-        var rankingInfo = getHighestRanking(item, keys, value, options);
-        var rank = rankingInfo.rank, _a = rankingInfo.keyThreshold, keyThreshold = _a === void 0 ? threshold : _a;
+        const rankingInfo = getHighestRanking(item, keys, value, options);
+        const { rank, keyThreshold = threshold } = rankingInfo;
         if (rank >= keyThreshold) {
-            matches.push(tslib_1.__assign(tslib_1.__assign({}, rankingInfo), { item: item, index: index }));
+            matches.push({
+                ...rankingInfo,
+                item,
+                index
+            });
         }
         return matches;
     }
 }
-exports.matchSorter = matchSorter;
 /**
  * Gets the highest ranking for value for the given item based on its values for the given keys
  * @param {*} item - the item to rank
@@ -65,30 +75,26 @@ exports.matchSorter = matchSorter;
  * @param {String} value - the value to rank against
  * @param {Object} options - options to control the ranking
  * @return {{rank: Number, keyIndex: Number, keyThreshold: Number}} - the highest ranking
- */
-function getHighestRanking(item, keys, value, options) {
+ */ function getHighestRanking(item, keys, value, options) {
     if (!keys) {
         // if keys is not specified, then we assume the item given is ready to be matched
-        var stringItem = item;
+        const stringItem = item;
         return {
             // ends up being duplicate of 'item' in matches but consistent
             rankedValue: stringItem,
             rank: getMatchRanking(stringItem, value, options),
             keyIndex: -1,
-            keyThreshold: options.threshold,
+            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;
+    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) {
+        } else if (newRank > maxRanking) {
             newRank = maxRanking;
         }
         if (newRank > rank) {
@@ -97,12 +103,17 @@ function getHighestRanking(item, keys, value, options) {
             keyThreshold = threshold;
             newRankedValue = itemValue;
         }
-        return { rankedValue: newRankedValue, rank: rank, keyIndex: keyIndex, keyThreshold: keyThreshold };
+        return {
+            rankedValue: newRankedValue,
+            rank,
+            keyIndex,
+            keyThreshold
+        };
     }, {
         rankedValue: item,
         rank: RANKING_NO_MATCH,
         keyIndex: -1,
-        keyThreshold: options.threshold,
+        keyThreshold: options.threshold
     });
 }
 /**
@@ -111,8 +122,7 @@ function getHighestRanking(item, keys, value, options) {
  * @param {String} stringToRank - the string to rank
  * @param {Object} options - options for the match (like keepDiacritics for comparison)
  * @returns {Number} the ranking for how well stringToRank matches testString
- */
-function getMatchRanking(testString, stringToRank, options) {
+ */ function getMatchRanking(testString, stringToRank, options) {
     testString = prepareValueForComparison(testString, options);
     stringToRank = prepareValueForComparison(stringToRank, options);
     // too long
@@ -135,14 +145,13 @@ function getMatchRanking(testString, stringToRank, options) {
         return RANKING_STARTS_WITH;
     }
     // word starts with
-    if (testString.includes(" ".concat(stringToRank))) {
+    if (testString.includes(` ${stringToRank}`)) {
         return RANKING_WORD_STARTS_WITH;
     }
     // contains
     if (testString.includes(stringToRank)) {
         return RANKING_CONTAINS;
-    }
-    else if (stringToRank.length === 1) {
+    } else if (stringToRank.length === 1) {
         // If the only character in the given stringToRank
         //   isn't even contained in the testString, then
         //   it's definitely not a match.
@@ -161,13 +170,12 @@ function getMatchRanking(testString, stringToRank, options) {
  *
  * @param {String} string the string for which to produce the acronym
  * @returns {String} the acronym
- */
-function getAcronym(string) {
-    var acronym = "";
-    var wordsInString = string.split(" ");
-    wordsInString.forEach(function (wordInString) {
-        var splitByHyphenWords = wordInString.split("-");
-        splitByHyphenWords.forEach(function (splitByHyphenWord) {
+ */ function getAcronym(string) {
+    let acronym = "";
+    const wordsInString = string.split(" ");
+    wordsInString.forEach((wordInString)=>{
+        const splitByHyphenWords = wordInString.split("-");
+        splitByHyphenWords.forEach((splitByHyphenWord)=>{
             acronym += splitByHyphenWord.substring(0, 1);
         });
     });
@@ -182,13 +190,12 @@ function getAcronym(string) {
  * @param {String} stringToRank - the string to rank
  * @returns {Number} the number between RANKING_MATCHES and
  * RANKING_MATCHES + 1 for how well stringToRank matches testString
- */
-function getClosenessRanking(testString, stringToRank) {
-    var matchingInOrderCharCount = 0;
-    var charNumber = 0;
+ */ function getClosenessRanking(testString, stringToRank) {
+    let matchingInOrderCharCount = 0;
+    let charNumber = 0;
     function findMatchingCharacter(matchChar, string, index) {
-        for (var j = index, J = string.length; j < J; j++) {
-            var stringChar = string[j];
+        for(let j = index, J = string.length; j < J; j++){
+            const stringChar = string[j];
             if (stringChar === matchChar) {
                 matchingInOrderCharCount += 1;
                 return j + 1;
@@ -197,25 +204,25 @@ function getClosenessRanking(testString, stringToRank) {
         return -1;
     }
     function getRanking(spread) {
-        var spreadPercentage = 1 / spread;
-        var inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
-        var ranking = RANKING_MATCHES + inOrderPercentage * spreadPercentage;
+        const spreadPercentage = 1 / spread;
+        const inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
+        const ranking = RANKING_MATCHES + inOrderPercentage * spreadPercentage;
         return ranking;
     }
-    var firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
+    const 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];
+    for(let i = 1, I = stringToRank.length; i < I; i++){
+        const matchChar = stringToRank[i];
         charNumber = findMatchingCharacter(matchChar, testString, charNumber);
-        var found = charNumber > -1;
+        const found = charNumber > -1;
         if (!found) {
             return RANKING_NO_MATCH;
         }
     }
-    var spread = charNumber - firstIndex;
+    const spread = charNumber - firstIndex;
     return getRanking(spread);
 }
 /**
@@ -223,23 +230,20 @@ function getClosenessRanking(testString, stringToRank) {
  * @param {Object} a - the first item to sort
  * @param {Object} b - the second item to sort
  * @return {Number} -1 if a should come first, 1 if b should come first, 0 if equal
- */
-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;
+ */ function 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) {
             // use the base sort function as a tie-breaker
             return baseSort(a, b);
-        }
-        else {
+        } else {
             return aKeyIndex < bKeyIndex ? aFirst : bFirst;
         }
-    }
-    else {
+    } else {
         return aRank > bRank ? aFirst : bFirst;
     }
 }
@@ -248,14 +252,12 @@ function sortRankedValues(a, b, baseSort) {
  * @param {String} value - the value to clean
  * @param {Object} options - {keepDiacritics: whether to remove diacritics}
  * @return {String} the prepared value
- */
-function prepareValueForComparison(value, _a) {
-    var keepDiacritics = _a.keepDiacritics;
+ */ function prepareValueForComparison(value, { keepDiacritics }) {
     // value might not actually be a string at this point (we don't get to choose)
     // so part of preparing the value for comparison is ensure that it is a string
-    value = "".concat(value); // toString
+    value = `${value}`; // toString
     if (!keepDiacritics) {
-        value = (0, removeAccents_1.default)(value);
+        value = (0, _removeAccents.default)(value);
     }
     return value;
 }
@@ -264,26 +266,21 @@ function prepareValueForComparison(value, _a) {
  * @param {Object} item - the item
  * @param {Object|Function} key - the potentially nested keypath or property callback
  * @return {Array} - an array containing the value(s) at the nested keypath
- */
-function getItemValues(item, key) {
+ */ function getItemValues(item, key) {
     if (typeof key === "object") {
         key = key.key;
     }
-    var value;
+    let value;
     if (typeof key === "function") {
         value = key(item);
-    }
-    else if (item == null) {
+    } else if (item == null) {
         value = null;
-    }
-    else if (Object.hasOwnProperty.call(item, key)) {
+    } else if (Object.hasOwnProperty.call(item, key)) {
         value = item[key];
-    }
-    else if (key.includes(".")) {
+    } else if (key.includes(".")) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         return getNestedValues(key, item);
-    }
-    else {
+    } else {
         value = null;
     }
     // because `value` can also be undefined
@@ -293,7 +290,9 @@ function getItemValues(item, key) {
     if (Array.isArray(value)) {
         return value;
     }
-    return [String(value)];
+    return [
+        String(value)
+    ];
 }
 /**
  * Given path: "foo.bar.baz"
@@ -301,24 +300,23 @@ function getItemValues(item, key) {
  *   -> 'buzz'
  * @param path a dot-separated set of keys
  * @param item the item to get the value from
- */
-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;
+ */ function 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)) {
-                var nestedValue = nestedItem[nestedKey];
+                const nestedValue = nestedItem[nestedKey];
                 if (nestedValue != null) {
                     nestedValues.push(nestedValue);
                 }
-            }
-            else if (nestedKey === "*") {
+            } else if (nestedKey === "*") {
                 // ensure that values is an array
                 nestedValues = nestedValues.concat(nestedItem);
             }
@@ -328,8 +326,8 @@ function getNestedValues(path, item) {
     if (Array.isArray(values[0])) {
         // keep allowing the implicit wildcard for an array of strings at the end of
         // the path; don't use `.flat()` because that's not available in node.js v10
-        var result = [];
-        return result.concat.apply(result, values);
+        const result = [];
+        return result.concat(...values);
     }
     // Based on our logic it should be an array of strings by now...
     // assuming the user's path terminated in strings
@@ -340,35 +338,36 @@ function getNestedValues(path, item) {
  * @param item - the item from which the values will be retrieved
  * @param keys - the keys to use to retrieve the values
  * @return objects with {itemValue, attributes}
- */
-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++) {
+ */ function 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: attributes,
+                attributes
             });
         }
     }
     return allValues;
 }
-var defaultKeyAttributes = {
+const defaultKeyAttributes = {
     maxRanking: Infinity,
-    minRanking: -Infinity,
+    minRanking: -Infinity
 };
 /**
  * Gets all the attributes for the given key
  * @param key - the key from which the attributes will be retrieved
  * @return object containing the key's attributes
- */
-function getKeyAttributes(key) {
+ */ function getKeyAttributes(key) {
     if (typeof key === "string") {
         return defaultKeyAttributes;
     }
-    return tslib_1.__assign(tslib_1.__assign({}, defaultKeyAttributes), key);
+    return {
+        ...defaultKeyAttributes,
+        ...key
+    };
 }
-exports.default = matchSorter;
+const _default = matchSorter;