numberq
/
foundry
1
0
Fork 0
Code Releases 1 Activity
All user data for FoundryVTT. Includes worlds, systems, modules, and any asset in the "foundryuserdata" directory. Does NOT include the FoundryVTT installation itself.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
22 Commits
1 Branch
1.7 GiB
 
 
 
Tree: 3231847b45
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3231847b45'
${ noResults }
foundry/Data/modules/token-variants/scripts/fuse/fuse.js

2436 lines
68 KiB
Raw Blame History

/**
* Fuse.js v6.5.3 - Lightweight fuzzy-search (http://fusejs.io)
*
* Copyright (c) 2021 Kiro Risk (http://kiro.me)
* All Rights Reserved. Apache Software License 2.0
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
enumerableOnly &&
(symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
})),
keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = null != arguments[i] ? arguments[i] : {};
i % 2
? ownKeys(Object(source), !0).forEach(function (key) {
_defineProperty(target, key, source[key]);
})
: Object.getOwnPropertyDescriptors
? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source))
: ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function _typeof(obj) {
'@babel/helpers - typeof';
return (
(_typeof =
'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator
? function (obj) {
return typeof obj;
}
: function (obj) {
return obj &&
'function' == typeof Symbol &&
obj.constructor === Symbol &&
obj !== Symbol.prototype
? 'symbol'
: typeof obj;
}),
_typeof(obj)
);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError('Cannot call a class as a function');
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ('value' in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, 'prototype', {
writable: false,
});
return Constructor;
}
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true,
});
} else {
obj[key] = value;
}
return obj;
}
function _inherits(subClass, superClass) {
if (typeof superClass !== 'function' && superClass !== null) {
throw new TypeError('Super expression must either be null or a function');
}
Object.defineProperty(subClass, 'prototype', {
value: Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true,
},
}),
writable: false,
});
if (superClass) _setPrototypeOf(subClass, superClass);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf
? Object.getPrototypeOf
: function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf =
Object.setPrototypeOf ||
function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _isNativeReflectConstruct() {
if (typeof Reflect === 'undefined' || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === 'function') return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
return true;
} catch (e) {
return false;
}
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _possibleConstructorReturn(self, call) {
if (call && (typeof call === 'object' || typeof call === 'function')) {
return call;
} else if (call !== void 0) {
throw new TypeError('Derived constructors may only return object or undefined');
}
return _assertThisInitialized(self);
}
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = _getPrototypeOf(Derived),
result;
if (hasNativeReflectConstruct) {
var NewTarget = _getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possibleConstructorReturn(this, result);
};
}
function _toConsumableArray(arr) {
return (
_arrayWithoutHoles(arr) ||
_iterableToArray(arr) ||
_unsupportedIterableToArray(arr) ||
_nonIterableSpread()
);
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _iterableToArray(iter) {
if (
(typeof Symbol !== 'undefined' && iter[Symbol.iterator] != null) ||
iter['@@iterator'] != null
)
return Array.from(iter);
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === 'Object' && o.constructor) n = o.constructor.name;
if (n === 'Map' || n === 'Set') return Array.from(o);
if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableSpread() {
throw new TypeError(
'Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.'
);
}
function isArray(value) {
return !Array.isArray ? getTag(value) === '[object Array]' : Array.isArray(value);
} // Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js
var INFINITY = 1 / 0;
function baseToString(value) {
// Exit early for strings to avoid a performance hit in some environments.
if (typeof value == 'string') {
return value;
}
var result = value + '';
return result == '0' && 1 / value == -INFINITY ? '-0' : result;
}
function toString(value) {
return value == null ? '' : baseToString(value);
}
function isString(value) {
return typeof value === 'string';
}
function isNumber(value) {
return typeof value === 'number';
} // Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js
function isBoolean(value) {
return (
value === true ||
value === false ||
(isObjectLike(value) && getTag(value) == '[object Boolean]')
);
}
function isObject(value) {
return _typeof(value) === 'object';
} // Checks if `value` is object-like.
function isObjectLike(value) {
return isObject(value) && value !== null;
}
function isDefined(value) {
return value !== undefined && value !== null;
}
function isBlank(value) {
return !value.trim().length;
} // Gets the `toStringTag` of `value`.
// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js
function getTag(value) {
return value == null
? value === undefined
? '[object Undefined]'
: '[object Null]'
: Object.prototype.toString.call(value);
}
var EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';
var INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
var LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = function LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key) {
return 'Invalid value for key '.concat(key);
};
var PATTERN_LENGTH_TOO_LARGE = function PATTERN_LENGTH_TOO_LARGE(max) {
return 'Pattern length exceeds max of '.concat(max, '.');
};
var MISSING_KEY_PROPERTY = function MISSING_KEY_PROPERTY(name) {
return 'Missing '.concat(name, ' property in key');
};
var INVALID_KEY_WEIGHT_VALUE = function INVALID_KEY_WEIGHT_VALUE(key) {
return "Property 'weight' in key '".concat(key, "' must be a positive integer");
};
var hasOwn = Object.prototype.hasOwnProperty;
var KeyStore = /*#__PURE__*/ (function () {
function KeyStore(keys) {
var _this = this;
_classCallCheck(this, KeyStore);
this._keys = [];
this._keyMap = {};
var totalWeight = 0;
keys.forEach(function (key) {
var obj = createKey(key);
totalWeight += obj.weight;
_this._keys.push(obj);
_this._keyMap[obj.id] = obj;
totalWeight += obj.weight;
}); // Normalize weights so that their sum is equal to 1
this._keys.forEach(function (key) {
key.weight /= totalWeight;
});
}
_createClass(KeyStore, [
{
key: 'get',
value: function get(keyId) {
return this._keyMap[keyId];
},
},
{
key: 'keys',
value: function keys() {
return this._keys;
},
},
{
key: 'toJSON',
value: function toJSON() {
return JSON.stringify(this._keys);
},
},
]);
return KeyStore;
})();
function createKey(key) {
var path = null;
var id = null;
var src = null;
var weight = 1;
if (isString(key) || isArray(key)) {
src = key;
path = createKeyPath(key);
id = createKeyId(key);
} else {
if (!hasOwn.call(key, 'name')) {
throw new Error(MISSING_KEY_PROPERTY('name'));
}
var name = key.name;
src = name;
if (hasOwn.call(key, 'weight')) {
weight = key.weight;
if (weight <= 0) {
throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
}
}
path = createKeyPath(name);
id = createKeyId(name);
}
return {
path: path,
id: id,
weight: weight,
src: src,
};
}
function createKeyPath(key) {
return isArray(key) ? key : key.split('.');
}
function createKeyId(key) {
return isArray(key) ? key.join('.') : key;
}
function get(obj, path) {
var list = [];
var arr = false;
var deepGet = function deepGet(obj, path, index) {
if (!isDefined(obj)) {
return;
}
if (!path[index]) {
// If there's no path left, we've arrived at the object we care about.
list.push(obj);
} else {
var key = path[index];
var value = obj[key];
if (!isDefined(value)) {
return;
} // If we're at the last value in the path, and if it's a string/number/bool,
// add it to the list
if (index === path.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
list.push(toString(value));
} else if (isArray(value)) {
arr = true; // Search each item in the array.
for (var i = 0, len = value.length; i < len; i += 1) {
deepGet(value[i], path, index + 1);
}
} else if (path.length) {
// An object. Recurse further.
deepGet(value, path, index + 1);
}
}
}; // Backwards compatibility (since path used to be a string)
deepGet(obj, isString(path) ? path.split('.') : path, 0);
return arr ? list : list[0];
}
var MatchOptions = {
// Whether the matches should be included in the result set. When `true`, each record in the result
// set will include the indices of the matched characters.
// These can consequently be used for highlighting purposes.
includeMatches: false,
// When `true`, the matching function will continue to the end of a search pattern even if
// a perfect match has already been located in the string.
findAllMatches: false,
// Minimum number of characters that must be matched before a result is considered a match
minMatchCharLength: 1,
};
var BasicOptions = {
// When `true`, the algorithm continues searching to the end of the input even if a perfect
// match is found before the end of the same input.
isCaseSensitive: false,
// When true, the matching function will continue to the end of a search pattern even if
includeScore: false,
// List of properties that will be searched. This also supports nested properties.
keys: [],
// Whether to sort the result list, by score
shouldSort: true,
// Default sort function: sort by ascending score, ascending index
sortFn: function sortFn(a, b) {
return a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1;
},
};
var FuzzyOptions = {
// Approximately where in the text is the pattern expected to be found?
location: 0,
// At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
// (of both letters and location), a threshold of '1.0' would match anything.
threshold: 0.6,
// Determines how close the match must be to the fuzzy location (specified above).
// An exact letter match which is 'distance' characters away from the fuzzy location
// would score as a complete mismatch. A distance of '0' requires the match be at
// the exact location specified, a threshold of '1000' would require a perfect match
// to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
distance: 100,
};
var AdvancedOptions = {
// When `true`, it enables the use of unix-like search commands
useExtendedSearch: false,
// The get function to use when fetching an object's properties.
// The default will search nested paths *ie foo.bar.baz*
getFn: get,
// When `true`, search will ignore `location` and `distance`, so it won't matter
// where in the string the pattern appears.
// More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
ignoreLocation: false,
// When `true`, the calculation for the relevance score (used for sorting) will
// ignore the field-length norm.
// More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
ignoreFieldNorm: false,
// The weight to determine how much field length norm effects scoring.
fieldNormWeight: 1,
};
var Config = _objectSpread2(
_objectSpread2(_objectSpread2(_objectSpread2({}, BasicOptions), MatchOptions), FuzzyOptions),
AdvancedOptions
);
var SPACE = /[^ ]+/g; // Field-length norm: the shorter the field, the higher the weight.
// Set to 3 decimals to reduce index size.
function norm() {
var weight = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
var mantissa = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
var cache = new Map();
var m = Math.pow(10, mantissa);
return {
get: function get(value) {
var numTokens = value.match(SPACE).length;
if (cache.has(numTokens)) {
return cache.get(numTokens);
} // Default function is 1/sqrt(x), weight makes that variable
var norm = 1 / Math.pow(numTokens, 0.5 * weight); // In place of `toFixed(mantissa)`, for faster computation
var n = parseFloat(Math.round(norm * m) / m);
cache.set(numTokens, n);
return n;
},
clear: function clear() {
cache.clear();
},
};
}
var FuseIndex = /*#__PURE__*/ (function () {
function FuseIndex() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$getFn = _ref.getFn,
getFn = _ref$getFn === void 0 ? Config.getFn : _ref$getFn,
_ref$fieldNormWeight = _ref.fieldNormWeight,
fieldNormWeight =
_ref$fieldNormWeight === void 0 ? Config.fieldNormWeight : _ref$fieldNormWeight;
_classCallCheck(this, FuseIndex);
this.norm = norm(fieldNormWeight, 3);
this.getFn = getFn;
this.isCreated = false;
this.setIndexRecords();
}
_createClass(FuseIndex, [
{
key: 'setSources',
value: function setSources() {
var docs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
this.docs = docs;
},
},
{
key: 'setIndexRecords',
value: function setIndexRecords() {
var records = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
this.records = records;
},
},
{
key: 'setKeys',
value: function setKeys() {
var _this = this;
var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
this.keys = keys;
this._keysMap = {};
keys.forEach(function (key, idx) {
_this._keysMap[key.id] = idx;
});
},
},
{
key: 'create',
value: function create() {
var _this2 = this;
if (this.isCreated || !this.docs.length) {
return;
}
this.isCreated = true; // List is Array<String>
if (isString(this.docs[0])) {
this.docs.forEach(function (doc, docIndex) {
_this2._addString(doc, docIndex);
});
} else {
// List is Array<Object>
this.docs.forEach(function (doc, docIndex) {
_this2._addObject(doc, docIndex);
});
}
this.norm.clear();
}, // Adds a doc to the end of the index
},
{
key: 'add',
value: function add(doc) {
var idx = this.size();
if (isString(doc)) {
this._addString(doc, idx);
} else {
this._addObject(doc, idx);
}
}, // Removes the doc at the specified index of the index
},
{
key: 'removeAt',
value: function removeAt(idx) {
this.records.splice(idx, 1); // Change ref index of every subsquent doc
for (var i = idx, len = this.size(); i < len; i += 1) {
this.records[i].i -= 1;
}
},
},
{
key: 'getValueForItemAtKeyId',
value: function getValueForItemAtKeyId(item, keyId) {
return item[this._keysMap[keyId]];
},
},
{
key: 'size',
value: function size() {
return this.records.length;
},
},
{
key: '_addString',
value: function _addString(doc, docIndex) {
if (!isDefined(doc) || isBlank(doc)) {
return;
}
var record = {
v: doc,
i: docIndex,
n: this.norm.get(doc),
};
this.records.push(record);
},
},
{
key: '_addObject',
value: function _addObject(doc, docIndex) {
var _this3 = this;
var record = {
i: docIndex,
$: {},
}; // Iterate over every key (i.e, path), and fetch the value at that key
this.keys.forEach(function (key, keyIndex) {
var value = _this3.getFn(doc, key.path);
if (!isDefined(value)) {
return;
}
if (isArray(value)) {
(function () {
var subRecords = [];
var stack = [
{
nestedArrIndex: -1,
value: value,
},
];
while (stack.length) {
var _stack$pop = stack.pop(),
nestedArrIndex = _stack$pop.nestedArrIndex,
_value = _stack$pop.value;
if (!isDefined(_value)) {
continue;
}
if (isString(_value) && !isBlank(_value)) {
var subRecord = {
v: _value,
i: nestedArrIndex,
n: _this3.norm.get(_value),
};
subRecords.push(subRecord);
} else if (isArray(_value)) {
_value.forEach(function (item, k) {
stack.push({
nestedArrIndex: k,
value: item,
});
});
} else;
}
record.$[keyIndex] = subRecords;
})();
} else if (!isBlank(value)) {
var subRecord = {
v: value,
n: _this3.norm.get(value),
};
record.$[keyIndex] = subRecord;
}
});
this.records.push(record);
},
},
{
key: 'toJSON',
value: function toJSON() {
return {
keys: this.keys,
records: this.records,
};
},
},
]);
return FuseIndex;
})();
function createIndex(keys, docs) {
var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
_ref2$getFn = _ref2.getFn,
getFn = _ref2$getFn === void 0 ? Config.getFn : _ref2$getFn,
_ref2$fieldNormWeight = _ref2.fieldNormWeight,
fieldNormWeight =
_ref2$fieldNormWeight === void 0 ? Config.fieldNormWeight : _ref2$fieldNormWeight;
var myIndex = new FuseIndex({
getFn: getFn,
fieldNormWeight: fieldNormWeight,
});
myIndex.setKeys(keys.map(createKey));
myIndex.setSources(docs);
myIndex.create();
return myIndex;
}
function parseIndex(data) {
var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
_ref3$getFn = _ref3.getFn,
getFn = _ref3$getFn === void 0 ? Config.getFn : _ref3$getFn,
_ref3$fieldNormWeight = _ref3.fieldNormWeight,
fieldNormWeight =
_ref3$fieldNormWeight === void 0 ? Config.fieldNormWeight : _ref3$fieldNormWeight;
var keys = data.keys,
records = data.records;
var myIndex = new FuseIndex({
getFn: getFn,
fieldNormWeight: fieldNormWeight,
});
myIndex.setKeys(keys);
myIndex.setIndexRecords(records);
return myIndex;
}
function computeScore$1(pattern) {
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
_ref$errors = _ref.errors,
errors = _ref$errors === void 0 ? 0 : _ref$errors,
_ref$currentLocation = _ref.currentLocation,
currentLocation = _ref$currentLocation === void 0 ? 0 : _ref$currentLocation,
_ref$expectedLocation = _ref.expectedLocation,
expectedLocation = _ref$expectedLocation === void 0 ? 0 : _ref$expectedLocation,
_ref$distance = _ref.distance,
distance = _ref$distance === void 0 ? Config.distance : _ref$distance,
_ref$ignoreLocation = _ref.ignoreLocation,
ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation;
var accuracy = errors / pattern.length;
if (ignoreLocation) {
return accuracy;
}
var proximity = Math.abs(expectedLocation - currentLocation);
if (!distance) {
// Dodge divide by zero error.
return proximity ? 1.0 : accuracy;
}
return accuracy + proximity / distance;
}
function convertMaskToIndices() {
var matchmask = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var minMatchCharLength =
arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Config.minMatchCharLength;
var indices = [];
var start = -1;
var end = -1;
var i = 0;
for (var len = matchmask.length; i < len; i += 1) {
var match = matchmask[i];
if (match && start === -1) {
start = i;
} else if (!match && start !== -1) {
end = i - 1;
if (end - start + 1 >= minMatchCharLength) {
indices.push([start, end]);
}
start = -1;
}
} // (i-1 - start) + 1 => i - start
if (matchmask[i - 1] && i - start >= minMatchCharLength) {
indices.push([start, i - 1]);
}
return indices;
}
// Machine word size
var MAX_BITS = 32;
function search(text, pattern, patternAlphabet) {
var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
_ref$location = _ref.location,
location = _ref$location === void 0 ? Config.location : _ref$location,
_ref$distance = _ref.distance,
distance = _ref$distance === void 0 ? Config.distance : _ref$distance,
_ref$threshold = _ref.threshold,
threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,
_ref$findAllMatches = _ref.findAllMatches,
findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,
_ref$minMatchCharLeng = _ref.minMatchCharLength,
minMatchCharLength =
_ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,
_ref$includeMatches = _ref.includeMatches,
includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,
_ref$ignoreLocation = _ref.ignoreLocation,
ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation;
if (pattern.length > MAX_BITS) {
throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
}
var patternLen = pattern.length; // Set starting location at beginning text and initialize the alphabet.
var textLen = text.length; // Handle the case when location > text.length
var expectedLocation = Math.max(0, Math.min(location, textLen)); // Highest score beyond which we give up.
var currentThreshold = threshold; // Is there a nearby exact match? (speedup)
var bestLocation = expectedLocation; // Performance: only computer matches when the minMatchCharLength > 1
// OR if `includeMatches` is true.
var computeMatches = minMatchCharLength > 1 || includeMatches; // A mask of the matches, used for building the indices
var matchMask = computeMatches ? Array(textLen) : [];
var index; // Get all exact matches, here for speed up
while ((index = text.indexOf(pattern, bestLocation)) > -1) {
var score = computeScore$1(pattern, {
currentLocation: index,
expectedLocation: expectedLocation,
distance: distance,
ignoreLocation: ignoreLocation,
});
currentThreshold = Math.min(score, currentThreshold);
bestLocation = index + patternLen;
if (computeMatches) {
var i = 0;
while (i < patternLen) {
matchMask[index + i] = 1;
i += 1;
}
}
} // Reset the best location
bestLocation = -1;
var lastBitArr = [];
var finalScore = 1;
var binMax = patternLen + textLen;
var mask = 1 << (patternLen - 1);
for (var _i = 0; _i < patternLen; _i += 1) {
// Scan for the best match; each iteration allows for one more error.
// Run a binary search to determine how far from the match location we can stray
// at this error level.
var binMin = 0;
var binMid = binMax;
while (binMin < binMid) {
var _score2 = computeScore$1(pattern, {
errors: _i,
currentLocation: expectedLocation + binMid,
expectedLocation: expectedLocation,
distance: distance,
ignoreLocation: ignoreLocation,
});
if (_score2 <= currentThreshold) {
binMin = binMid;
} else {
binMax = binMid;
}
binMid = Math.floor((binMax - binMin) / 2 + binMin);
} // Use the result from this iteration as the maximum for the next.
binMax = binMid;
var start = Math.max(1, expectedLocation - binMid + 1);
var finish = findAllMatches
? textLen
: Math.min(expectedLocation + binMid, textLen) + patternLen; // Initialize the bit array
var bitArr = Array(finish + 2);
bitArr[finish + 1] = (1 << _i) - 1;
for (var j = finish; j >= start; j -= 1) {
var currentLocation = j - 1;
var charMatch = patternAlphabet[text.charAt(currentLocation)];
if (computeMatches) {
// Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)
matchMask[currentLocation] = +!!charMatch;
} // First pass: exact match
bitArr[j] = ((bitArr[j + 1] << 1) | 1) & charMatch; // Subsequent passes: fuzzy match
if (_i) {
bitArr[j] |= ((lastBitArr[j + 1] | lastBitArr[j]) << 1) | 1 | lastBitArr[j + 1];
}
if (bitArr[j] & mask) {
finalScore = computeScore$1(pattern, {
errors: _i,
currentLocation: currentLocation,
expectedLocation: expectedLocation,
distance: distance,
ignoreLocation: ignoreLocation,
}); // This match will almost certainly be better than any existing match.
// But check anyway.
if (finalScore <= currentThreshold) {
// Indeed it is
currentThreshold = finalScore;
bestLocation = currentLocation; // Already passed `loc`, downhill from here on in.
if (bestLocation <= expectedLocation) {
break;
} // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.
start = Math.max(1, 2 * expectedLocation - bestLocation);
}
}
} // No hope for a (better) match at greater error levels.
var _score = computeScore$1(pattern, {
errors: _i + 1,
currentLocation: expectedLocation,
expectedLocation: expectedLocation,
distance: distance,
ignoreLocation: ignoreLocation,
});
if (_score > currentThreshold) {
break;
}
lastBitArr = bitArr;
}
var result = {
isMatch: bestLocation >= 0,
// Count exact matches (those with a score of 0) to be "almost" exact
score: Math.max(0.001, finalScore),
};
if (computeMatches) {
var indices = convertMaskToIndices(matchMask, minMatchCharLength);
if (!indices.length) {
result.isMatch = false;
} else if (includeMatches) {
result.indices = indices;
}
}
return result;
}
function createPatternAlphabet(pattern) {
var mask = {};
for (var i = 0, len = pattern.length; i < len; i += 1) {
var _char = pattern.charAt(i);
mask[_char] = (mask[_char] || 0) | (1 << (len - i - 1));
}
return mask;
}
var BitapSearch = /*#__PURE__*/ (function () {
function BitapSearch(pattern) {
var _this = this;
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
_ref$location = _ref.location,
location = _ref$location === void 0 ? Config.location : _ref$location,
_ref$threshold = _ref.threshold,
threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,
_ref$distance = _ref.distance,
distance = _ref$distance === void 0 ? Config.distance : _ref$distance,
_ref$includeMatches = _ref.includeMatches,
includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,
_ref$findAllMatches = _ref.findAllMatches,
findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,
_ref$minMatchCharLeng = _ref.minMatchCharLength,
minMatchCharLength =
_ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,
_ref$isCaseSensitive = _ref.isCaseSensitive,
isCaseSensitive =
_ref$isCaseSensitive === void 0 ? Config.isCaseSensitive : _ref$isCaseSensitive,
_ref$ignoreLocation = _ref.ignoreLocation,
ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation;
_classCallCheck(this, BitapSearch);
this.options = {
location: location,
threshold: threshold,
distance: distance,
includeMatches: includeMatches,
findAllMatches: findAllMatches,
minMatchCharLength: minMatchCharLength,
isCaseSensitive: isCaseSensitive,
ignoreLocation: ignoreLocation,
};
this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
this.chunks = [];
if (!this.pattern.length) {
return;
}
var addChunk = function addChunk(pattern, startIndex) {
_this.chunks.push({
pattern: pattern,
alphabet: createPatternAlphabet(pattern),
startIndex: startIndex,
});
};
var len = this.pattern.length;
if (len > MAX_BITS) {
var i = 0;
var remainder = len % MAX_BITS;
var end = len - remainder;
while (i < end) {
addChunk(this.pattern.substr(i, MAX_BITS), i);
i += MAX_BITS;
}
if (remainder) {
var startIndex = len - MAX_BITS;
addChunk(this.pattern.substr(startIndex), startIndex);
}
} else {
addChunk(this.pattern, 0);
}
}
_createClass(BitapSearch, [
{
key: 'searchIn',
value: function searchIn(text) {
var _this$options = this.options,
isCaseSensitive = _this$options.isCaseSensitive,
includeMatches = _this$options.includeMatches;
if (!isCaseSensitive) {
text = text.toLowerCase();
} // Exact match
if (this.pattern === text) {
var _result = {
isMatch: true,
score: 0,
};
if (includeMatches) {
_result.indices = [[0, text.length - 1]];
}
return _result;
} // Otherwise, use Bitap algorithm
var _this$options2 = this.options,
location = _this$options2.location,
distance = _this$options2.distance,
threshold = _this$options2.threshold,
findAllMatches = _this$options2.findAllMatches,
minMatchCharLength = _this$options2.minMatchCharLength,
ignoreLocation = _this$options2.ignoreLocation;
var allIndices = [];
var totalScore = 0;
var hasMatches = false;
this.chunks.forEach(function (_ref2) {
var pattern = _ref2.pattern,
alphabet = _ref2.alphabet,
startIndex = _ref2.startIndex;
var _search = search(text, pattern, alphabet, {
location: location + startIndex,
distance: distance,
threshold: threshold,
findAllMatches: findAllMatches,
minMatchCharLength: minMatchCharLength,
includeMatches: includeMatches,
ignoreLocation: ignoreLocation,
}),
isMatch = _search.isMatch,
score = _search.score,
indices = _search.indices;
if (isMatch) {
hasMatches = true;
}
totalScore += score;
if (isMatch && indices) {
allIndices = [].concat(_toConsumableArray(allIndices), _toConsumableArray(indices));
}
});
var result = {
isMatch: hasMatches,
score: hasMatches ? totalScore / this.chunks.length : 1,
};
if (hasMatches && includeMatches) {
result.indices = allIndices;
}
return result;
},
},
]);
return BitapSearch;
})();
var BaseMatch = /*#__PURE__*/ (function () {
function BaseMatch(pattern) {
_classCallCheck(this, BaseMatch);
this.pattern = pattern;
}
_createClass(
BaseMatch,
[
{
key: 'search',
value: function /*text*/ search() {},
},
],
[
{
key: 'isMultiMatch',
value: function isMultiMatch(pattern) {
return getMatch(pattern, this.multiRegex);
},
},
{
key: 'isSingleMatch',
value: function isSingleMatch(pattern) {
return getMatch(pattern, this.singleRegex);
},
},
]
);
return BaseMatch;
})();
function getMatch(pattern, exp) {
var matches = pattern.match(exp);
return matches ? matches[1] : null;
}
var ExactMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(ExactMatch, _BaseMatch);
var _super = _createSuper(ExactMatch);
function ExactMatch(pattern) {
_classCallCheck(this, ExactMatch);
return _super.call(this, pattern);
}
_createClass(
ExactMatch,
[
{
key: 'search',
value: function search(text) {
var isMatch = text === this.pattern;
return {
isMatch: isMatch,
score: isMatch ? 0 : 1,
indices: [0, this.pattern.length - 1],
};
},
},
],
[
{
key: 'type',
get: function get() {
return 'exact';
},
},
{
key: 'multiRegex',
get: function get() {
return /^="(.*)"$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^=(.*)$/;
},
},
]
);
return ExactMatch;
})(BaseMatch);
var InverseExactMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(InverseExactMatch, _BaseMatch);
var _super = _createSuper(InverseExactMatch);
function InverseExactMatch(pattern) {
_classCallCheck(this, InverseExactMatch);
return _super.call(this, pattern);
}
_createClass(
InverseExactMatch,
[
{
key: 'search',
value: function search(text) {
var index = text.indexOf(this.pattern);
var isMatch = index === -1;
return {
isMatch: isMatch,
score: isMatch ? 0 : 1,
indices: [0, text.length - 1],
};
},
},
],
[
{
key: 'type',
get: function get() {
return 'inverse-exact';
},
},
{
key: 'multiRegex',
get: function get() {
return /^!"(.*)"$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^!(.*)$/;
},
},
]
);
return InverseExactMatch;
})(BaseMatch);
var PrefixExactMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(PrefixExactMatch, _BaseMatch);
var _super = _createSuper(PrefixExactMatch);
function PrefixExactMatch(pattern) {
_classCallCheck(this, PrefixExactMatch);
return _super.call(this, pattern);
}
_createClass(
PrefixExactMatch,
[
{
key: 'search',
value: function search(text) {
var isMatch = text.startsWith(this.pattern);
return {
isMatch: isMatch,
score: isMatch ? 0 : 1,
indices: [0, this.pattern.length - 1],
};
},
},
],
[
{
key: 'type',
get: function get() {
return 'prefix-exact';
},
},
{
key: 'multiRegex',
get: function get() {
return /^\^"(.*)"$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^\^(.*)$/;
},
},
]
);
return PrefixExactMatch;
})(BaseMatch);
var InversePrefixExactMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(InversePrefixExactMatch, _BaseMatch);
var _super = _createSuper(InversePrefixExactMatch);
function InversePrefixExactMatch(pattern) {
_classCallCheck(this, InversePrefixExactMatch);
return _super.call(this, pattern);
}
_createClass(
InversePrefixExactMatch,
[
{
key: 'search',
value: function search(text) {
var isMatch = !text.startsWith(this.pattern);
return {
isMatch: isMatch,
score: isMatch ? 0 : 1,
indices: [0, text.length - 1],
};
},
},
],
[
{
key: 'type',
get: function get() {
return 'inverse-prefix-exact';
},
},
{
key: 'multiRegex',
get: function get() {
return /^!\^"(.*)"$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^!\^(.*)$/;
},
},
]
);
return InversePrefixExactMatch;
})(BaseMatch);
var SuffixExactMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(SuffixExactMatch, _BaseMatch);
var _super = _createSuper(SuffixExactMatch);
function SuffixExactMatch(pattern) {
_classCallCheck(this, SuffixExactMatch);
return _super.call(this, pattern);
}
_createClass(
SuffixExactMatch,
[
{
key: 'search',
value: function search(text) {
var isMatch = text.endsWith(this.pattern);
return {
isMatch: isMatch,
score: isMatch ? 0 : 1,
indices: [text.length - this.pattern.length, text.length - 1],
};
},
},
],
[
{
key: 'type',
get: function get() {
return 'suffix-exact';
},
},
{
key: 'multiRegex',
get: function get() {
return /^"(.*)"\$$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^(.*)\$$/;
},
},
]
);
return SuffixExactMatch;
})(BaseMatch);
var InverseSuffixExactMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(InverseSuffixExactMatch, _BaseMatch);
var _super = _createSuper(InverseSuffixExactMatch);
function InverseSuffixExactMatch(pattern) {
_classCallCheck(this, InverseSuffixExactMatch);
return _super.call(this, pattern);
}
_createClass(
InverseSuffixExactMatch,
[
{
key: 'search',
value: function search(text) {
var isMatch = !text.endsWith(this.pattern);
return {
isMatch: isMatch,
score: isMatch ? 0 : 1,
indices: [0, text.length - 1],
};
},
},
],
[
{
key: 'type',
get: function get() {
return 'inverse-suffix-exact';
},
},
{
key: 'multiRegex',
get: function get() {
return /^!"(.*)"\$$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^!(.*)\$$/;
},
},
]
);
return InverseSuffixExactMatch;
})(BaseMatch);
var FuzzyMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(FuzzyMatch, _BaseMatch);
var _super = _createSuper(FuzzyMatch);
function FuzzyMatch(pattern) {
var _this;
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
_ref$location = _ref.location,
location = _ref$location === void 0 ? Config.location : _ref$location,
_ref$threshold = _ref.threshold,
threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,
_ref$distance = _ref.distance,
distance = _ref$distance === void 0 ? Config.distance : _ref$distance,
_ref$includeMatches = _ref.includeMatches,
includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,
_ref$findAllMatches = _ref.findAllMatches,
findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,
_ref$minMatchCharLeng = _ref.minMatchCharLength,
minMatchCharLength =
_ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,
_ref$isCaseSensitive = _ref.isCaseSensitive,
isCaseSensitive =
_ref$isCaseSensitive === void 0 ? Config.isCaseSensitive : _ref$isCaseSensitive,
_ref$ignoreLocation = _ref.ignoreLocation,
ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation;
_classCallCheck(this, FuzzyMatch);
_this = _super.call(this, pattern);
_this._bitapSearch = new BitapSearch(pattern, {
location: location,
threshold: threshold,
distance: distance,
includeMatches: includeMatches,
findAllMatches: findAllMatches,
minMatchCharLength: minMatchCharLength,
isCaseSensitive: isCaseSensitive,
ignoreLocation: ignoreLocation,
});
return _this;
}
_createClass(
FuzzyMatch,
[
{
key: 'search',
value: function search(text) {
return this._bitapSearch.searchIn(text);
},
},
],
[
{
key: 'type',
get: function get() {
return 'fuzzy';
},
},
{
key: 'multiRegex',
get: function get() {
return /^"(.*)"$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^(.*)$/;
},
},
]
);
return FuzzyMatch;
})(BaseMatch);
var IncludeMatch = /*#__PURE__*/ (function (_BaseMatch) {
_inherits(IncludeMatch, _BaseMatch);
var _super = _createSuper(IncludeMatch);
function IncludeMatch(pattern) {
_classCallCheck(this, IncludeMatch);
return _super.call(this, pattern);
}
_createClass(
IncludeMatch,
[
{
key: 'search',
value: function search(text) {
var location = 0;
var index;
var indices = [];
var patternLen = this.pattern.length; // Get all exact matches
while ((index = text.indexOf(this.pattern, location)) > -1) {
location = index + patternLen;
indices.push([index, location - 1]);
}
var isMatch = !!indices.length;
return {
isMatch: isMatch,
score: isMatch ? 0 : 1,
indices: indices,
};
},
},
],
[
{
key: 'type',
get: function get() {
return 'include';
},
},
{
key: 'multiRegex',
get: function get() {
return /^'"(.*)"$/;
},
},
{
key: 'singleRegex',
get: function get() {
return /^'(.*)$/;
},
},
]
);
return IncludeMatch;
})(BaseMatch);
var searchers = [
ExactMatch,
IncludeMatch,
PrefixExactMatch,
InversePrefixExactMatch,
InverseSuffixExactMatch,
SuffixExactMatch,
InverseExactMatch,
FuzzyMatch,
];
var searchersLen = searchers.length; // Regex to split by spaces, but keep anything in quotes together
var SPACE_RE = / +(?=([^\"]*\"[^\"]*\")*[^\"]*$)/;
var OR_TOKEN = '|'; // Return a 2D array representation of the query, for simpler parsing.
// Example:
// "^core go$ | rb$ | py$ xy$" => [["^core", "go$"], ["rb$"], ["py$", "xy$"]]
function parseQuery(pattern) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
return pattern.split(OR_TOKEN).map(function (item) {
var query = item
.trim()
.split(SPACE_RE)
.filter(function (item) {
return item && !!item.trim();
});
var results = [];
for (var i = 0, len = query.length; i < len; i += 1) {
var queryItem = query[i]; // 1. Handle multiple query match (i.e, once that are quoted, like `"hello world"`)
var found = false;
var idx = -1;
while (!found && ++idx < searchersLen) {
var searcher = searchers[idx];
var token = searcher.isMultiMatch(queryItem);
if (token) {
results.push(new searcher(token, options));
found = true;
}
}
if (found) {
continue;
} // 2. Handle single query matches (i.e, once that are *not* quoted)
idx = -1;
while (++idx < searchersLen) {
var _searcher = searchers[idx];
var _token = _searcher.isSingleMatch(queryItem);
if (_token) {
results.push(new _searcher(_token, options));
break;
}
}
}
return results;
});
}
// to a singl match
var MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);
/**
* Command-like searching
* ======================
*
* Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,
* search in a given text.
*
* Search syntax:
*
* | Token | Match type | Description |
* | ----------- | -------------------------- | -------------------------------------- |
* | `jscript` | fuzzy-match | Items that fuzzy match `jscript` |
* | `=scheme` | exact-match | Items that are `scheme` |
* | `'python` | include-match | Items that include `python` |
* | `!ruby` | inverse-exact-match | Items that do not include `ruby` |
* | `^java` | prefix-exact-match | Items that start with `java` |
* | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |
* | `.js$` | suffix-exact-match | Items that end with `.js` |
* | `!.go$` | inverse-suffix-exact-match | Items that do not end with `.go` |
*
* A single pipe character acts as an OR operator. For example, the following
* query matches entries that start with `core` and end with either`go`, `rb`,
* or`py`.
*
* ```
* ^core go$ | rb$ | py$
* ```
*/
var ExtendedSearch = /*#__PURE__*/ (function () {
function ExtendedSearch(pattern) {
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
_ref$isCaseSensitive = _ref.isCaseSensitive,
isCaseSensitive =
_ref$isCaseSensitive === void 0 ? Config.isCaseSensitive : _ref$isCaseSensitive,
_ref$includeMatches = _ref.includeMatches,
includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,
_ref$minMatchCharLeng = _ref.minMatchCharLength,
minMatchCharLength =
_ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,
_ref$ignoreLocation = _ref.ignoreLocation,
ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation,
_ref$findAllMatches = _ref.findAllMatches,
findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,
_ref$location = _ref.location,
location = _ref$location === void 0 ? Config.location : _ref$location,
_ref$threshold = _ref.threshold,
threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,
_ref$distance = _ref.distance,
distance = _ref$distance === void 0 ? Config.distance : _ref$distance;
_classCallCheck(this, ExtendedSearch);
this.query = null;
this.options = {
isCaseSensitive: isCaseSensitive,
includeMatches: includeMatches,
minMatchCharLength: minMatchCharLength,
findAllMatches: findAllMatches,
ignoreLocation: ignoreLocation,
location: location,
threshold: threshold,
distance: distance,
};
this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
this.query = parseQuery(this.pattern, this.options);
}
_createClass(
ExtendedSearch,
[
{
key: 'searchIn',
value: function searchIn(text) {
var query = this.query;
if (!query) {
return {
isMatch: false,
score: 1,
};
}
var _this$options = this.options,
includeMatches = _this$options.includeMatches,
isCaseSensitive = _this$options.isCaseSensitive;
text = isCaseSensitive ? text : text.toLowerCase();
var numMatches = 0;
var allIndices = [];
var totalScore = 0; // ORs
for (var i = 0, qLen = query.length; i < qLen; i += 1) {
var searchers = query[i]; // Reset indices
allIndices.length = 0;
numMatches = 0; // ANDs
for (var j = 0, pLen = searchers.length; j < pLen; j += 1) {
var searcher = searchers[j];
var _searcher$search = searcher.search(text),
isMatch = _searcher$search.isMatch,
indices = _searcher$search.indices,
score = _searcher$search.score;
if (isMatch) {
numMatches += 1;
totalScore += score;
if (includeMatches) {
var type = searcher.constructor.type;
if (MultiMatchSet.has(type)) {
allIndices = [].concat(
_toConsumableArray(allIndices),
_toConsumableArray(indices)
);
} else {
allIndices.push(indices);
}
}
} else {
totalScore = 0;
numMatches = 0;
allIndices.length = 0;
break;
}
} // OR condition, so if TRUE, return
if (numMatches) {
var result = {
isMatch: true,
score: totalScore / numMatches,
};
if (includeMatches) {
result.indices = allIndices;
}
return result;
}
} // Nothing was matched
return {
isMatch: false,
score: 1,
};
},
},
],
[
{
key: 'condition',
value: function condition(_, options) {
return options.useExtendedSearch;
},
},
]
);
return ExtendedSearch;
})();
var registeredSearchers = [];
function register() {
registeredSearchers.push.apply(registeredSearchers, arguments);
}
function createSearcher(pattern, options) {
for (var i = 0, len = registeredSearchers.length; i < len; i += 1) {
var searcherClass = registeredSearchers[i];
if (searcherClass.condition(pattern, options)) {
return new searcherClass(pattern, options);
}
}
return new BitapSearch(pattern, options);
}
var LogicalOperator = {
AND: '$and',
OR: '$or',
};
var KeyType = {
PATH: '$path',
PATTERN: '$val',
};
var isExpression = function isExpression(query) {
return !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
};
var isPath = function isPath(query) {
return !!query[KeyType.PATH];
};
var isLeaf = function isLeaf(query) {
return !isArray(query) && isObject(query) && !isExpression(query);
};
var convertToExplicit = function convertToExplicit(query) {
return _defineProperty(
{},
LogicalOperator.AND,
Object.keys(query).map(function (key) {
return _defineProperty({}, key, query[key]);
})
);
}; // When `auto` is `true`, the parse function will infer and initialize and add
// the appropriate `Searcher` instance
function parse(query, options) {
var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
_ref3$auto = _ref3.auto,
auto = _ref3$auto === void 0 ? true : _ref3$auto;
var next = function next(query) {
var keys = Object.keys(query);
var isQueryPath = isPath(query);
if (!isQueryPath && keys.length > 1 && !isExpression(query)) {
return next(convertToExplicit(query));
}
if (isLeaf(query)) {
var key = isQueryPath ? query[KeyType.PATH] : keys[0];
var pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];
if (!isString(pattern)) {
throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
}
var obj = {
keyId: createKeyId(key),
pattern: pattern,
};
if (auto) {
obj.searcher = createSearcher(pattern, options);
}
return obj;
}
var node = {
children: [],
operator: keys[0],
};
keys.forEach(function (key) {
var value = query[key];
if (isArray(value)) {
value.forEach(function (item) {
node.children.push(next(item));
});
}
});
return node;
};
if (!isExpression(query)) {
query = convertToExplicit(query);
}
return next(query);
}
function computeScore(results, _ref) {
var _ref$ignoreFieldNorm = _ref.ignoreFieldNorm,
ignoreFieldNorm =
_ref$ignoreFieldNorm === void 0 ? Config.ignoreFieldNorm : _ref$ignoreFieldNorm;
results.forEach(function (result) {
var totalScore = 1;
result.matches.forEach(function (_ref2) {
var key = _ref2.key,
norm = _ref2.norm,
score = _ref2.score;
var weight = key ? key.weight : null;
totalScore *= Math.pow(
score === 0 && weight ? Number.EPSILON : score,
(weight || 1) * (ignoreFieldNorm ? 1 : norm)
);
});
result.score = totalScore;
});
}
function transformMatches(result, data) {
var matches = result.matches;
data.matches = [];
if (!isDefined(matches)) {
return;
}
matches.forEach(function (match) {
if (!isDefined(match.indices) || !match.indices.length) {
return;
}
var indices = match.indices,
value = match.value;
var obj = {
indices: indices,
value: value,
};
if (match.key) {
obj.key = match.key.src;
}
if (match.idx > -1) {
obj.refIndex = match.idx;
}
data.matches.push(obj);
});
}
function transformScore(result, data) {
data.score = result.score;
}
function format(results, docs) {
var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
_ref$includeMatches = _ref.includeMatches,
includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,
_ref$includeScore = _ref.includeScore,
includeScore = _ref$includeScore === void 0 ? Config.includeScore : _ref$includeScore;
var transformers = [];
if (includeMatches) transformers.push(transformMatches);
if (includeScore) transformers.push(transformScore);
return results.map(function (result) {
var idx = result.idx;
var data = {
item: docs[idx],
refIndex: idx,
};
if (transformers.length) {
transformers.forEach(function (transformer) {
transformer(result, data);
});
}
return data;
});
}
var Fuse$1 = /*#__PURE__*/ (function () {
function Fuse(docs) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var index = arguments.length > 2 ? arguments[2] : undefined;
_classCallCheck(this, Fuse);
this.options = _objectSpread2(_objectSpread2({}, Config), options);
if (this.options.useExtendedSearch && !true) {
throw new Error(EXTENDED_SEARCH_UNAVAILABLE);
}
this._keyStore = new KeyStore(this.options.keys);
this.setCollection(docs, index);
}
_createClass(Fuse, [
{
key: 'setCollection',
value: function setCollection(docs, index) {
this._docs = docs;
if (index && !(index instanceof FuseIndex)) {
throw new Error(INCORRECT_INDEX_TYPE);
}
this._myIndex =
index ||
createIndex(this.options.keys, this._docs, {
getFn: this.options.getFn,
fieldNormWeight: this.options.fieldNormWeight,
});
},
},
{
key: 'add',
value: function add(doc) {
if (!isDefined(doc)) {
return;
}
this._docs.push(doc);
this._myIndex.add(doc);
},
},
{
key: 'remove',
value: function remove() {
var predicate =
arguments.length > 0 && arguments[0] !== undefined
? arguments[0]
: function () /* doc, idx */
{
return false;
};
var results = [];
for (var i = 0, len = this._docs.length; i < len; i += 1) {
var doc = this._docs[i];
if (predicate(doc, i)) {
this.removeAt(i);
i -= 1;
len -= 1;
results.push(doc);
}
}
return results;
},
},
{
key: 'removeAt',
value: function removeAt(idx) {
this._docs.splice(idx, 1);
this._myIndex.removeAt(idx);
},
},
{
key: 'getIndex',
value: function getIndex() {
return this._myIndex;
},
},
{
key: 'search',
value: function search(query) {
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
_ref$limit = _ref.limit,
limit = _ref$limit === void 0 ? -1 : _ref$limit;
var _this$options = this.options,
includeMatches = _this$options.includeMatches,
includeScore = _this$options.includeScore,
shouldSort = _this$options.shouldSort,
sortFn = _this$options.sortFn,
ignoreFieldNorm = _this$options.ignoreFieldNorm;
var results = isString(query)
? isString(this._docs[0])
? this._searchStringList(query)
: this._searchObjectList(query)
: this._searchLogical(query);
computeScore(results, {
ignoreFieldNorm: ignoreFieldNorm,
});
if (shouldSort) {
results.sort(sortFn);
}
if (isNumber(limit) && limit > -1) {
results = results.slice(0, limit);
}
return format(results, this._docs, {
includeMatches: includeMatches,
includeScore: includeScore,
});
},
},
{
key: '_searchStringList',
value: function _searchStringList(query) {
var searcher = createSearcher(query, this.options);
var records = this._myIndex.records;
var results = []; // Iterate over every string in the index
records.forEach(function (_ref2) {
var text = _ref2.v,
idx = _ref2.i,
norm = _ref2.n;
if (!isDefined(text)) {
return;
}
var _searcher$searchIn = searcher.searchIn(text),
isMatch = _searcher$searchIn.isMatch,
score = _searcher$searchIn.score,
indices = _searcher$searchIn.indices;
if (isMatch) {
results.push({
item: text,
idx: idx,
matches: [
{
score: score,
value: text,
norm: norm,
indices: indices,
},
],
});
}
});
return results;
},
},
{
key: '_searchLogical',
value: function _searchLogical(query) {
var _this = this;
var expression = parse(query, this.options);
var evaluate = function evaluate(node, item, idx) {
if (!node.children) {
var keyId = node.keyId,
searcher = node.searcher;
var matches = _this._findMatches({
key: _this._keyStore.get(keyId),
value: _this._myIndex.getValueForItemAtKeyId(item, keyId),
searcher: searcher,
});
if (matches && matches.length) {
return [
{
idx: idx,
item: item,
matches: matches,
},
];
}
return [];
}
var res = [];
for (var i = 0, len = node.children.length; i < len; i += 1) {
var child = node.children[i];
var result = evaluate(child, item, idx);
if (result.length) {
res.push.apply(res, _toConsumableArray(result));
} else if (node.operator === LogicalOperator.AND) {
return [];
}
}
return res;
};
var records = this._myIndex.records;
var resultMap = {};
var results = [];
records.forEach(function (_ref3) {
var item = _ref3.$,
idx = _ref3.i;
if (isDefined(item)) {
var expResults = evaluate(expression, item, idx);
if (expResults.length) {
// Dedupe when adding
if (!resultMap[idx]) {
resultMap[idx] = {
idx: idx,
item: item,
matches: [],
};
results.push(resultMap[idx]);
}
expResults.forEach(function (_ref4) {
var _resultMap$idx$matche;
var matches = _ref4.matches;
(_resultMap$idx$matche = resultMap[idx].matches).push.apply(
_resultMap$idx$matche,
_toConsumableArray(matches)
);
});
}
}
});
return results;
},
},
{
key: '_searchObjectList',
value: function _searchObjectList(query) {
var _this2 = this;
var searcher = createSearcher(query, this.options);
var _this$_myIndex = this._myIndex,
keys = _this$_myIndex.keys,
records = _this$_myIndex.records;
var results = []; // List is Array<Object>
records.forEach(function (_ref5) {
var item = _ref5.$,
idx = _ref5.i;
if (!isDefined(item)) {
return;
}
var matches = []; // Iterate over every key (i.e, path), and fetch the value at that key
keys.forEach(function (key, keyIndex) {
matches.push.apply(
matches,
_toConsumableArray(
_this2._findMatches({
key: key,
value: item[keyIndex],
searcher: searcher,
})
)
);
});
if (matches.length) {
results.push({
idx: idx,
item: item,
matches: matches,
});
}
});
return results;
},
},
{
key: '_findMatches',
value: function _findMatches(_ref6) {
var key = _ref6.key,
value = _ref6.value,
searcher = _ref6.searcher;
if (!isDefined(value)) {
return [];
}
var matches = [];
if (isArray(value)) {
value.forEach(function (_ref7) {
var text = _ref7.v,
idx = _ref7.i,
norm = _ref7.n;
if (!isDefined(text)) {
return;
}
var _searcher$searchIn2 = searcher.searchIn(text),
isMatch = _searcher$searchIn2.isMatch,
score = _searcher$searchIn2.score,
indices = _searcher$searchIn2.indices;
if (isMatch) {
matches.push({
score: score,
key: key,
value: text,
idx: idx,
norm: norm,
indices: indices,
});
}
});
} else {
var text = value.v,
norm = value.n;
var _searcher$searchIn3 = searcher.searchIn(text),
isMatch = _searcher$searchIn3.isMatch,
score = _searcher$searchIn3.score,
indices = _searcher$searchIn3.indices;
if (isMatch) {
matches.push({
score: score,
key: key,
value: text,
norm: norm,
indices: indices,
});
}
}
return matches;
},
},
]);
return Fuse;
})();
Fuse$1.version = '6.5.3';
Fuse$1.createIndex = createIndex;
Fuse$1.parseIndex = parseIndex;
Fuse$1.config = Config;
{
Fuse$1.parseQuery = parse;
}
{
register(ExtendedSearch);
}
export var Fuse = Fuse$1;