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

package/matchSorter.cjs.js

@@ -5,244 +5,99 @@ 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');
+require('./accentsSets.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 };
+let r=(e,t)=>String(e.rankedValue).localeCompare(String(t.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
+ */l=(e,t,l={})=>{let{keys:u,threshold:a=1,baseSort:o=r,sorter:s=e=>e.sort((e,t)=>i(e,t,o))}=l;return s(e.reduce(function(e,r,o){let i=n(r,u,t,l),{rank:s,keyThreshold:h=a}=i;return s>=h&&e.push({...i,item:r,index:o}),e},[])).map(({item:e})=>e)},/**
+ * Gets the highest ranking for value for the given item based on its values for the given keys
+ * @param {*} item - the item to rank
+ * @param {Array} keys - the keys to get values from the item for the ranking
+ * @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
+ */n=(e,t,r,l)=>t?c(e,t).reduce(({rank:e,rankedValue:t,keyIndex:n,keyThreshold:a},{itemValue:o,attributes:i},s)=>{let h=u(o,r,l),f=t,{minRanking:c,maxRanking:d,threshold:k}=i;return h<c&&h>=1?h=c:h>d&&(h=d),h>e&&(e=h,n=s,a=k,f=o),{rankedValue:f,rank:e,keyIndex:n,keyThreshold:a}},{rankedValue:e,rank:0,keyIndex:-1,keyThreshold:l.threshold}):{// ends up being duplicate of 'item' in matches but consistent
+    rankedValue:// if keys is not specified, then we assume the item given is ready to be matched
+    e,rank:u(e,r,l),keyIndex:-1,keyThreshold:l.threshold},/**
+ * Gives a rankings score based on how well the two strings match.
+ * @param {String} testString - the string to test against
+ * @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
+ */u=(e,t,r)=>// too long
+    (e=s(e,r),(t=s(t,r)).length>e.length)?0:// case sensitive equals
+    e===t?7:// case insensitive equals
+    // Lower casing before further comparison
+    (e=e.toLowerCase())===(t=t.toLowerCase())?6:// starts with
+    e.startsWith(t)?5:// word starts with
+    e.includes(` ${t}`)?4:// contains
+    e.includes(t)?3:1===t.length?0:// If the only character in the given stringToRank
+    //   isn't even contained in the testString, then
+    //   it's definitely not a match.
+    // acronym
+    a(e).includes(t)?2:// will return a number between RANKING_MATCHES and
+    // RANKING_MATCHES + 1 depending  on how close of a match it is.
+    o(e,t),/**
+ * Generates an acronym for a string.
+ *
+ * @param {String} string the string for which to produce the acronym
+ * @returns {String} the acronym
+ */a=e=>{let t="";return e.split(" ").forEach(e=>{e.split("-").forEach(e=>{t+=e.substring(0,1);});}),t},/**
+ * Returns a score based on how spread apart the
+ * characters from the stringToRank are within the testString.
+ * A number close to RANKING_MATCHES represents a loose match. A number close
+ * to RANKING_MATCHES + 1 represents a tighter match.
+ * @param {String} testString - the string to test against
+ * @param {String} stringToRank - the string to rank
+ * @returns {Number} the number between RANKING_MATCHES and
+ * RANKING_MATCHES + 1 for how well stringToRank matches testString
+ */o=(e,t)=>{let r=0,l=0;function n(e,t,l){for(let n=l,u=t.length;n<u;n++)if(t[n]===e)return r+=1,n+1;return -1}let u=n(t[0],e,0);if(u<0)return 0;l=u;for(let r=1,u=t.length;r<u;r++)if(!((l=n(t[r],e,l))>-1))return 0;return 1+1/(l-u)*(r/t.length)},/**
+ * Sorts items that have a rank, index, and keyIndex
+ * @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
+ */i=(e,t,r)=>{let{rank:l,keyIndex:n}=e,{rank:u,keyIndex:a}=t;return l!==u?l>u?-1:1:n===a?// use the base sort function as a tie-breaker
+r(e,t):n<a?-1:1},/**
+ * Prepares value for comparison by stringifying it, removing diacritics (if specified)
+ * @param {String} value - the value to clean
+ * @param {Object} options - {keepDiacritics: whether to remove diacritics}
+ * @return {String} the prepared value
+ */s=(e,{keepDiacritics:r})=>(// 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
+    e=`${e}`,// toString
+    r||(e=removeAccents.removeAccents(e)),e),/**
+ * Gets value for key in item at arbitrarily nested keypath
+ * @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
+ */h=(e,t)=>{let r;if("object"==typeof t&&(t=t.key),"function"==typeof t)r=t(e);else if(null==e)r=null;else if(Object.hasOwnProperty.call(e,t))r=e[t];else {if(t.includes("."))// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+return f(t,e);r=null;}return(// because `value` can also be undefined
+null==r?[]:Array.isArray(r)?r:[String(r)])},/**
+ * Given path: "foo.bar.baz"
+ * And item: {foo: {bar: {baz: 'buzz'}}}
+ *   -> 'buzz'
+ * @param path a dot-separated set of keys
+ * @param item the item to get the value from
+ */f=(e,t)=>{let r=e.split("."),l=[t];for(let e=0,t=r.length;e<t;e++){let t=r[e],n=[];for(let e=0,r=l.length;e<r;e++){let r=l[e];if(null!=r){if(Object.hasOwnProperty.call(r,t)){let e=r[t];null!=e&&n.push(e);}else "*"===t&&// ensure that values is an array
+(n=n.concat(r));}}l=n;}return Array.isArray(l[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
+[].concat(...l):// Based on our logic it should be an array of strings by now...
+// assuming the user's path terminated in strings
+l},/**
+ * Gets all the values for the given keys in the given item and returns an array of those values
+ * @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}
+ */c=(e,t)=>{let r=[];for(let l=0,n=t.length;l<n;l++){let n=t[l],u=k(n),a=h(e,n);for(let e=0,t=a.length;e<t;e++)r.push({itemValue:a[e],attributes:u});}return r},d={maxRanking:1/0,minRanking:-1/0},/**
+ * 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
+ */k=t=>isString.isString(t)?d:{...d,...t};
 
-exports["default"] = matchSorter;
-exports.defaultBaseSortFn = defaultBaseSortFn;
-exports.matchSorter = matchSorter;
+exports["default"] = l;
+exports.defaultBaseSortFn = r;
+exports.matchSorter = l;

package/matchSorter.d.ts

@@ -48,7 +48,7 @@ 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 let defaultBaseSortFn: BaseSorter<unknown>;
-declare let matchSorter: <ItemType = string>(items: readonly ItemType[], value: string, options?: MatchSorterOptions<ItemType>) => ItemType[];
+declare let matchSorter: <ItemType = string>(items: ReadonlyArray<ItemType>, value: string, options?: MatchSorterOptions<ItemType>) => Array<ItemType>;
 export { matchSorter, defaultBaseSortFn };
 export type { MatchSorterOptions, KeyAttributesOptions, KeyOption, KeyAttributes, RankingInfo, ValueGetterKey, };
 export default matchSorter;