Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/match-sorter/dist/match-sorter.cjs.js
f646e1f695a7paginated-inlines

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;