@tanstack/react-query-devtools 4.18.0 → 4.19.1

package/build/umd/index.development.js

@@ -734,7 +734,6 @@
     MATCHES: 1,
     NO_MATCH: 0
   };
-
   /**
    * Gets the highest ranking for value for the given item based on its values for the given keys
    * @param {*} item - the item to rank
@@ -745,10 +744,8 @@
    */
   function rankItem(item, value, options) {
     var _options$threshold;
-
     options = options || {};
     options.threshold = (_options$threshold = options.threshold) != null ? _options$threshold : rankings.MATCHES;
-
     if (!options.accessors) {
       // if keys is not specified, then we assume the item given is ready to be matched
       const rank = getMatchRanking(item, value, options);
@@ -761,7 +758,6 @@
         passed: rank >= options.threshold
       };
     }
-
     const valuesToRank = getAllValuesToRank(item, options.accessors);
     const rankingInfo = {
       rankedValue: item,
@@ -770,34 +766,31 @@
       accessorThreshold: options.threshold,
       passed: false
     };
-
     for (let i = 0; i < valuesToRank.length; i++) {
       const rankValue = valuesToRank[i];
       let newRank = getMatchRanking(rankValue.itemValue, value, options);
       const {
         minRanking,
         maxRanking,
-        threshold
+        threshold = options.threshold
       } = rankValue.attributes;
-
       if (newRank < minRanking && newRank >= rankings.MATCHES) {
         newRank = minRanking;
       } else if (newRank > maxRanking) {
         newRank = maxRanking;
       }
-
       newRank = Math.min(newRank, maxRanking);
-
-      if (newRank > rankingInfo.rank) {
+      if (newRank >= threshold && newRank > rankingInfo.rank) {
         rankingInfo.rank = newRank;
+        rankingInfo.passed = true;
         rankingInfo.accessorIndex = i;
         rankingInfo.accessorThreshold = threshold;
         rankingInfo.rankedValue = rankValue.itemValue;
       }
     }
-
     return rankingInfo;
   }
+
   /**
    * Gives a rankings score based on how well the two strings match.
    * @param {String} testString - the string to test against
@@ -805,39 +798,40 @@
    * @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) {
     testString = prepareValueForComparison(testString, options);
-    stringToRank = prepareValueForComparison(stringToRank, options); // too long
+    stringToRank = prepareValueForComparison(stringToRank, options);
 
+    // too long
     if (stringToRank.length > testString.length) {
       return rankings.NO_MATCH;
-    } // case sensitive equals
-
+    }
 
+    // case sensitive equals
     if (testString === stringToRank) {
       return rankings.CASE_SENSITIVE_EQUAL;
-    } // Lower casing before further comparison
-
+    }
 
+    // Lower casing before further comparison
     testString = testString.toLowerCase();
-    stringToRank = stringToRank.toLowerCase(); // case insensitive equals
+    stringToRank = stringToRank.toLowerCase();
 
+    // case insensitive equals
     if (testString === stringToRank) {
       return rankings.EQUAL;
-    } // starts with
-
+    }
 
+    // starts with
     if (testString.startsWith(stringToRank)) {
       return rankings.STARTS_WITH;
-    } // word starts with
-
+    }
 
-    if (testString.includes(" " + stringToRank)) {
+    // word starts with
+    if (testString.includes(` ${stringToRank}`)) {
       return rankings.WORD_STARTS_WITH;
-    } // contains
-
+    }
 
+    // contains
     if (testString.includes(stringToRank)) {
       return rankings.CONTAINS;
     } else if (stringToRank.length === 1) {
@@ -845,25 +839,24 @@
       //   isn't even contained in the testString, then
       //   it's definitely not a match.
       return rankings.NO_MATCH;
-    } // acronym
-
+    }
 
+    // acronym
     if (getAcronym(testString).includes(stringToRank)) {
       return rankings.ACRONYM;
-    } // will return a number between rankings.MATCHES and
-    // rankings.MATCHES + 1 depending  on how close of a match it is.
-
+    }
 
+    // will return a number between rankings.MATCHES and
+    // rankings.MATCHES + 1 depending  on how close of a match it is.
     return getClosenessRanking(testString, stringToRank);
   }
+
   /**
    * Generates an acronym for a string.
    *
    * @param {String} string the string for which to produce the acronym
    * @returns {String} the acronym
    */
-
-
   function getAcronym(string) {
     let acronym = '';
     const wordsInString = string.split(' ');
@@ -875,6 +868,7 @@
     });
     return acronym;
   }
+
   /**
    * Returns a score based on how spread apart the
    * characters from the stringToRank are within the testString.
@@ -885,117 +879,96 @@
    * @returns {Number} the number between rankings.MATCHES and
    * rankings.MATCHES + 1 for how well stringToRank matches testString
    */
-
-
   function 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 = rankings.MATCHES + inOrderPercentage * spreadPercentage;
       return ranking;
     }
-
     const firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
-
     if (firstIndex < 0) {
       return rankings.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 rankings.NO_MATCH;
       }
     }
-
     const spread = charNumber - firstIndex;
     return getRanking(spread);
   }
+
   /**
    * 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
    */
-
   function prepareValueForComparison(value, _ref) {
     let {
       keepDiacritics
     } = _ref;
     // 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 = "" + value; // toString
-
+    value = `${value}`; // toString
     if (!keepDiacritics) {
       value = removeAccents(value);
     }
-
     return value;
   }
+
   /**
    * 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
    */
-
-
   function getItemValues(item, accessor) {
     let accessorFn = accessor;
-
     if (typeof accessor === 'object') {
       accessorFn = accessor.accessor;
     }
+    const value = accessorFn(item);
 
-    const value = accessorFn(item); // because `value` can also be undefined
-
+    // because `value` can also be undefined
     if (value == null) {
       return [];
     }
-
     if (Array.isArray(value)) {
       return value;
     }
-
     return [String(value)];
   }
+
   /**
    * 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}
    */
-
-
   function getAllValuesToRank(item, accessors) {
     const allValues = [];
-
     for (let j = 0, J = accessors.length; j < J; j++) {
       const accessor = accessors[j];
       const attributes = getAccessorAttributes(accessor);
       const itemValues = getItemValues(item, accessor);
-
       for (let i = 0, I = itemValues.length; i < I; i++) {
         allValues.push({
           itemValue: itemValues[i],
@@ -1003,10 +976,8 @@
         });
       }
     }
-
     return allValues;
   }
-
   const defaultKeyAttributes = {
     maxRanking: Infinity,
     minRanking: -Infinity
@@ -1016,13 +987,12 @@
    * @param accessor - the accessor from which the attributes will be retrieved
    * @return object containing the accessor's attributes
    */
-
   function getAccessorAttributes(accessor) {
     if (typeof accessor === 'function') {
       return defaultKeyAttributes;
     }
-
-    return { ...defaultKeyAttributes,
+    return {
+      ...defaultKeyAttributes,
       ...accessor
     };
   }