Homec4science
Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/match-sorter/dist/match-sorter.cjs.js
49c99f97fe9aissn4frontend

Last Change
Raw File

match-sorter.cjs.js
View Options

'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var _extends = require('@babel/runtime/helpers/extends');
var removeAccents = require('remove-accents');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
var removeAccents__default = /*#__PURE__*/_interopDefaultLegacy(removeAccents);
var rankings = {
CASE_SENSITIVE_EQUAL: 7,
EQUAL: 6,
STARTS_WITH: 5,
WORD_STARTS_WITH: 4,
CONTAINS: 3,
ACRONYM: 2,
MATCHES: 1,
NO_MATCH: 0
};
matchSorter.rankings = rankings;
var defaultBaseSortFn = function defaultBaseSortFn(a, b) {
return 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 _options = options,
keys = _options.keys,
_options$threshold = _options.threshold,
threshold = _options$threshold === void 0 ? rankings.MATCHES : _options$threshold,
_options$baseSort = _options.baseSort,
baseSort = _options$baseSort === void 0 ? defaultBaseSortFn : _options$baseSort,
_options$sorter = _options.sorter,
sorter = _options$sorter === void 0 ? function (matchedItems) {
return matchedItems.sort(function (a, b) {
return sortRankedValues(a, b, baseSort);
});
} : _options$sorter;
var matchedItems = items.reduce(reduceItemsToRanked, []);
return sorter(matchedItems).map(function (_ref) {
var item = _ref.item;
return item;
});
function reduceItemsToRanked(matches, item, index) {
var rankingInfo = getHighestRanking(item, keys, value, options);
var rank = rankingInfo.rank,
_rankingInfo$keyThres = rankingInfo.keyThreshold,
keyThreshold = _rankingInfo$keyThres === void 0 ? threshold : _rankingInfo$keyThres;
if (rank >= keyThreshold) {
matches.push(_extends__default['default']({}, rankingInfo, {
item: item,
index: index
}));
}
return matches;
}
}
/**
* 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
*/
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;
return {
// ends up being duplicate of 'item' in matches but consistent
rankedValue: stringItem,
rank: getMatchRanking(stringItem, value, options),
keyIndex: -1,
keyThreshold: options.threshold
};
}
var valuesToRank = getAllValuesToRank(item, keys);
return valuesToRank.reduce(function (_ref2, _ref3, i) {
var rank = _ref2.rank,
rankedValue = _ref2.rankedValue,
keyIndex = _ref2.keyIndex,
keyThreshold = _ref2.keyThreshold;
var itemValue = _ref3.itemValue,
attributes = _ref3.attributes;
var newRank = getMatchRanking(itemValue, value, options);
var newRankedValue = rankedValue;
var minRanking = attributes.minRanking,
maxRanking = attributes.maxRanking,
threshold = attributes.threshold;
if (newRank < minRanking && newRank >= rankings.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: rankings.NO_MATCH,
keyIndex: -1,
keyThreshold: options.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
*/
function getMatchRanking(testString, stringToRank, options) {
testString = prepareValueForComparison(testString, options);
stringToRank = prepareValueForComparison(stringToRank, options); // too long
if (stringToRank.length > testString.length) {
return rankings.NO_MATCH;
} // case sensitive equals
if (testString === stringToRank) {
return rankings.CASE_SENSITIVE_EQUAL;
} // Lower casing before further comparison
testString = testString.toLowerCase();
stringToRank = stringToRank.toLowerCase(); // case insensitive equals
if (testString === stringToRank) {
return rankings.EQUAL;
} // starts with
if (testString.startsWith(stringToRank)) {
return rankings.STARTS_WITH;
} // word starts with
if (testString.includes(" " + stringToRank)) {
return rankings.WORD_STARTS_WITH;
} // contains
if (testString.includes(stringToRank)) {
return rankings.CONTAINS;
} 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.
return rankings.NO_MATCH;
} // 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.
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) {
var acronym = '';
var wordsInString = string.split(' ');
wordsInString.forEach(function (wordInString) {
var splitByHyphenWords = wordInString.split('-');
splitByHyphenWords.forEach(function (splitByHyphenWord) {
acronym += splitByHyphenWord.substr(0, 1);
});
});
return acronym;
}
/**
* Returns a score based on how spread apart the
* characters from the stringToRank are within the testString.
* A number close to rankings.MATCHES represents a loose match. A number close
* to rankings.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 rankings.MATCHES and
* rankings.MATCHES + 1 for how well stringToRank matches testString
*/
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 = rankings.MATCHES + inOrderPercentage * spreadPercentage;
return ranking;
}
var firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
if (firstIndex < 0) {
return rankings.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 rankings.NO_MATCH;
}
}
var spread = charNumber - firstIndex;
return getRanking(spread);
}
/**
* 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
*/
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) {
// use the base sort function as a tie-breaker
return baseSort(a, b);
} else {
return aKeyIndex < bKeyIndex ? aFirst : bFirst;
}
} else {
return aRank > bRank ? aFirst : bFirst;
}
}
/**
* 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, _ref4) {
var keepDiacritics = _ref4.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 = "" + value; // toString
if (!keepDiacritics) {
value = removeAccents__default['default'](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, 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('.')) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-call
return getNestedValues(key, item);
} else {
value = null;
} // because `value` can also be undefined
if (value == null) {
return [];
}
if (Array.isArray(value)) {
return value;
}
return [String(value)];
}
/**
* 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
*/
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 === '*') {
// ensure that values is an array
nestedValues = nestedValues.concat(nestedItem);
}
}
values = nestedValues;
}
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);
} // Based on our logic it should be an array of strings by now...
// assuming the user's path terminated in strings
return values;
}
/**
* 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, 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
};
/**
* 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) {
if (typeof key === 'string') {
return defaultKeyAttributes;
}
return _extends__default['default']({}, defaultKeyAttributes, key);
}
/*
eslint
no-continue: "off",
*/
exports.defaultBaseSortFn = defaultBaseSortFn;
exports.matchSorter = matchSorter;
exports.rankings = rankings;
c4science · Help