Very Popular
Latest
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236/** * Fuse.js v6.4.1 - Lightweight fuzzy-search (http://fusejs.io) * * Copyright (c) 2020 Kiro Risk (http://kiro.me) * All Rights Reserved. Apache Software License 2.0 * * http://www.apache.org/licenses/LICENSE-2.0 */
function isArray(value) { return !Array.isArray ? getTag(value) === '[object Array]' : Array.isArray(value)}
// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.jsconst INFINITY = 1 / 0;function baseToString(value) { // Exit early for strings to avoid a performance hit in some environments. if (typeof value == 'string') { return value } let 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.jsfunction 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.jsfunction getTag(value) { return value == null ? value === undefined ? '[object Undefined]' : '[object Null]' : Object.prototype.toString.call(value)}
const EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';
const LOGICAL_SEARCH_UNAVAILABLE = 'Logical search is not available';
const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
const PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
const MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
const INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
const hasOwn = Object.prototype.hasOwnProperty;
class KeyStore { constructor(keys) { this._keys = []; this._keyMap = {};
let totalWeight = 0;
keys.forEach((key) => { let 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((key) => { key.weight /= totalWeight; }); } get(keyId) { return this._keyMap[keyId] } keys() { return this._keys } toJSON() { return JSON.stringify(this._keys) }}
function createKey(key) { let path = null; let id = null; let src = null; let 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')) }
const 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, id, weight, src }}
function createKeyPath(key) { return isArray(key) ? key : key.split('.')}
function createKeyId(key) { return isArray(key) ? key.join('.') : key}
function get(obj, path) { let list = []; let arr = false;
const deepGet = (obj, path, index) => { if (!path[index]) { // If there's no path left, we've arrived at the object we care about. list.push(obj); } else { let key = path[index];
const 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 (let 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]}
const 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};
const 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: (a, b) => a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1};
const 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};
const 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};
var Config = { ...BasicOptions, ...MatchOptions, ...FuzzyOptions, ...AdvancedOptions};
const SPACE = /[^ ]+/g;
// Field-length norm: the shorter the field, the higher the weight.// Set to 3 decimals to reduce index size.function norm(mantissa = 3) { const cache = new Map();
return { get(value) { const numTokens = value.match(SPACE).length;
if (cache.has(numTokens)) { return cache.get(numTokens) }
const n = parseFloat((1 / Math.sqrt(numTokens)).toFixed(mantissa));
cache.set(numTokens, n);
return n }, clear() { cache.clear(); } }}
class FuseIndex { constructor({ getFn = Config.getFn } = {}) { this.norm = norm(3); this.getFn = getFn; this.isCreated = false;
this.setIndexRecords(); } setSources(docs = []) { this.docs = docs; } setIndexRecords(records = []) { this.records = records; } setKeys(keys = []) { this.keys = keys; this._keysMap = {}; keys.forEach((key, idx) => { this._keysMap[key.id] = idx; }); } create() { if (this.isCreated || !this.docs.length) { return }
this.isCreated = true;
// List is Array<String> if (isString(this.docs[0])) { this.docs.forEach((doc, docIndex) => { this._addString(doc, docIndex); }); } else { // List is Array<Object> this.docs.forEach((doc, docIndex) => { this._addObject(doc, docIndex); }); }
this.norm.clear(); } // Adds a doc to the end of the index add(doc) { const 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 removeAt(idx) { this.records.splice(idx, 1);
// Change ref index of every subsquent doc for (let i = idx, len = this.size(); i < len; i += 1) { this.records[i].i -= 1; } } getValueForItemAtKeyId(item, keyId) { return item[this._keysMap[keyId]] } size() { return this.records.length } _addString(doc, docIndex) { if (!isDefined(doc) || isBlank(doc)) { return }
let record = { v: doc, i: docIndex, n: this.norm.get(doc) };
this.records.push(record); } _addObject(doc, docIndex) { let record = { i: docIndex, $: {} };
// Iterate over every key (i.e, path), and fetch the value at that key this.keys.forEach((key, keyIndex) => { // console.log(key) let value = this.getFn(doc, key.path);
if (!isDefined(value)) { return }
if (isArray(value)) { let subRecords = []; const stack = [{ nestedArrIndex: -1, value }];
while (stack.length) { const { nestedArrIndex, value } = stack.pop();
if (!isDefined(value)) { continue }
if (isString(value) && !isBlank(value)) { let subRecord = { v: value, i: nestedArrIndex, n: this.norm.get(value) };
subRecords.push(subRecord); } else if (isArray(value)) { value.forEach((item, k) => { stack.push({ nestedArrIndex: k, value: item }); }); } } record.$[keyIndex] = subRecords; } else if (!isBlank(value)) { let subRecord = { v: value, n: this.norm.get(value) };
record.$[keyIndex] = subRecord; } });
this.records.push(record); } toJSON() { return { keys: this.keys, records: this.records } }}
function createIndex(keys, docs, { getFn = Config.getFn } = {}) { const myIndex = new FuseIndex({ getFn }); myIndex.setKeys(keys.map(createKey)); myIndex.setSources(docs); myIndex.create(); return myIndex}
function parseIndex(data, { getFn = Config.getFn } = {}) { const { keys, records } = data; const myIndex = new FuseIndex({ getFn }); myIndex.setKeys(keys); myIndex.setIndexRecords(records); return myIndex}
function transformMatches(result, data) { const matches = result.matches; data.matches = [];
if (!isDefined(matches)) { return }
matches.forEach((match) => { if (!isDefined(match.indices) || !match.indices.length) { return }
const { indices, value } = match;
let obj = { indices, 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 computeScore( pattern, { errors = 0, currentLocation = 0, expectedLocation = 0, distance = Config.distance, ignoreLocation = Config.ignoreLocation } = {}) { const accuracy = errors / pattern.length;
if (ignoreLocation) { return accuracy }
const proximity = Math.abs(expectedLocation - currentLocation);
if (!distance) { // Dodge divide by zero error. return proximity ? 1.0 : accuracy }
return accuracy + proximity / distance}
function convertMaskToIndices( matchmask = [], minMatchCharLength = Config.minMatchCharLength) { let indices = []; let start = -1; let end = -1; let i = 0;
for (let len = matchmask.length; i < len; i += 1) { let 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 sizeconst MAX_BITS = 32;
function search( text, pattern, patternAlphabet, { location = Config.location, distance = Config.distance, threshold = Config.threshold, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, includeMatches = Config.includeMatches, ignoreLocation = Config.ignoreLocation } = {}) { if (pattern.length > MAX_BITS) { throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS)) }
const patternLen = pattern.length; // Set starting location at beginning text and initialize the alphabet. const textLen = text.length; // Handle the case when location > text.length const expectedLocation = Math.max(0, Math.min(location, textLen)); // Highest score beyond which we give up. let currentThreshold = threshold; // Is there a nearby exact match? (speedup) let bestLocation = expectedLocation;
// Performance: only computer matches when the minMatchCharLength > 1 // OR if `includeMatches` is true. const computeMatches = minMatchCharLength > 1 || includeMatches; // A mask of the matches, used for building the indices const matchMask = computeMatches ? Array(textLen) : [];
let index;
// Get all exact matches, here for speed up while ((index = text.indexOf(pattern, bestLocation)) > -1) { let score = computeScore(pattern, { currentLocation: index, expectedLocation, distance, ignoreLocation });
currentThreshold = Math.min(score, currentThreshold); bestLocation = index + patternLen;
if (computeMatches) { let i = 0; while (i < patternLen) { matchMask[index + i] = 1; i += 1; } } }
// Reset the best location bestLocation = -1;
let lastBitArr = []; let finalScore = 1; let binMax = patternLen + textLen;
const mask = 1 << (patternLen - 1);
for (let 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. let binMin = 0; let binMid = binMax;
while (binMin < binMid) { const score = computeScore(pattern, { errors: i, currentLocation: expectedLocation + binMid, expectedLocation, distance, ignoreLocation });
if (score <= 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;
let start = Math.max(1, expectedLocation - binMid + 1); let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
// Initialize the bit array let bitArr = Array(finish + 2);
bitArr[finish + 1] = (1 << i) - 1;
for (let j = finish; j >= start; j -= 1) { let currentLocation = j - 1; let 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(pattern, { errors: i, currentLocation, expectedLocation, distance, 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. const score = computeScore(pattern, { errors: i + 1, currentLocation: expectedLocation, expectedLocation, distance, ignoreLocation });
if (score > currentThreshold) { break }
lastBitArr = bitArr; }
const 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) { const indices = convertMaskToIndices(matchMask, minMatchCharLength); if (!indices.length) { result.isMatch = false; } else if (includeMatches) { result.indices = indices; } }
return result}
function createPatternAlphabet(pattern) { let mask = {};
for (let i = 0, len = pattern.length; i < len; i += 1) { const char = pattern.charAt(i); mask[char] = (mask[char] || 0) | (1 << (len - i - 1)); }
return mask}
class BitapSearch { constructor( pattern, { location = Config.location, threshold = Config.threshold, distance = Config.distance, includeMatches = Config.includeMatches, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, isCaseSensitive = Config.isCaseSensitive, ignoreLocation = Config.ignoreLocation } = {} ) { this.options = { location, threshold, distance, includeMatches, findAllMatches, minMatchCharLength, isCaseSensitive, ignoreLocation };
this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
this.chunks = [];
if (!this.pattern.length) { return }
const addChunk = (pattern, startIndex) => { this.chunks.push({ pattern, alphabet: createPatternAlphabet(pattern), startIndex }); };
const len = this.pattern.length;
if (len > MAX_BITS) { let i = 0; const remainder = len % MAX_BITS; const end = len - remainder;
while (i < end) { addChunk(this.pattern.substr(i, MAX_BITS), i); i += MAX_BITS; }
if (remainder) { const startIndex = len - MAX_BITS; addChunk(this.pattern.substr(startIndex), startIndex); } } else { addChunk(this.pattern, 0); } }
searchIn(text) { const { isCaseSensitive, includeMatches } = this.options;
if (!isCaseSensitive) { text = text.toLowerCase(); }
// Exact match if (this.pattern === text) { let result = { isMatch: true, score: 0 };
if (includeMatches) { result.indices = [[0, text.length - 1]]; }
return result }
// Otherwise, use Bitap algorithm const { location, distance, threshold, findAllMatches, minMatchCharLength, ignoreLocation } = this.options;
let allIndices = []; let totalScore = 0; let hasMatches = false;
this.chunks.forEach(({ pattern, alphabet, startIndex }) => { const { isMatch, score, indices } = search(text, pattern, alphabet, { location: location + startIndex, distance, threshold, findAllMatches, minMatchCharLength, includeMatches, ignoreLocation });
if (isMatch) { hasMatches = true; }
totalScore += score;
if (isMatch && indices) { allIndices = [...allIndices, ...indices]; } });
let result = { isMatch: hasMatches, score: hasMatches ? totalScore / this.chunks.length : 1 };
if (hasMatches && includeMatches) { result.indices = allIndices; }
return result }}
const registeredSearchers = [];
function createSearcher(pattern, options) { for (let i = 0, len = registeredSearchers.length; i < len; i += 1) { let searcherClass = registeredSearchers[i]; if (searcherClass.condition(pattern, options)) { return new searcherClass(pattern, options) } }
return new BitapSearch(pattern, options)}
const LogicalOperator = { AND: '$and', OR: '$or'};
const KeyType = { PATH: '$path', PATTERN: '$val'};
const isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
const isPath = (query) => !!query[KeyType.PATH];
const isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
const convertToExplicit = (query) => ({ [LogicalOperator.AND]: Object.keys(query).map((key) => ({ [key]: query[key] }))});
// When `auto` is `true`, the parse function will infer and initialize and add// the appropriate `Searcher` instancefunction parse(query, options, { auto = true } = {}) { const next = (query) => { let keys = Object.keys(query);
const isQueryPath = isPath(query);
if (!isQueryPath && keys.length > 1 && !isExpression(query)) { return next(convertToExplicit(query)) }
if (isLeaf(query)) { const key = isQueryPath ? query[KeyType.PATH] : keys[0];
const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];
if (!isString(pattern)) { throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key)) }
const obj = { keyId: createKeyId(key), pattern };
if (auto) { obj.searcher = createSearcher(pattern, options); }
return obj }
let node = { children: [], operator: keys[0] };
keys.forEach((key) => { const value = query[key];
if (isArray(value)) { value.forEach((item) => { node.children.push(next(item)); }); } });
return node };
if (!isExpression(query)) { query = convertToExplicit(query); }
return next(query)}
class Fuse { constructor(docs, options = {}, index) { this.options = { ...Config, ...options };
if ( this.options.useExtendedSearch && !false ) { throw new Error(EXTENDED_SEARCH_UNAVAILABLE) }
this._keyStore = new KeyStore(this.options.keys);
this.setCollection(docs, index); }
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 }); }
add(doc) { if (!isDefined(doc)) { return }
this._docs.push(doc); this._myIndex.add(doc); }
remove(predicate = (/* doc, idx */) => false) { const results = [];
for (let i = 0, len = this._docs.length; i < len; i += 1) { const doc = this._docs[i]; if (predicate(doc, i)) { this.removeAt(i); i -= 1;
results.push(doc); } }
return results }
removeAt(idx) { this._docs.splice(idx, 1); this._myIndex.removeAt(idx); }
getIndex() { return this._myIndex }
search(query, { limit = -1 } = {}) { const { includeMatches, includeScore, shouldSort, sortFn, ignoreFieldNorm } = this.options;
let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
computeScore$1(results, { ignoreFieldNorm });
if (shouldSort) { results.sort(sortFn); }
if (isNumber(limit) && limit > -1) { results = results.slice(0, limit); }
return format(results, this._docs, { includeMatches, includeScore }) }
_searchStringList(query) { const searcher = createSearcher(query, this.options); const { records } = this._myIndex; const results = [];
// Iterate over every string in the index records.forEach(({ v: text, i: idx, n: norm }) => { if (!isDefined(text)) { return }
const { isMatch, score, indices } = searcher.searchIn(text);
if (isMatch) { results.push({ item: text, idx, matches: [{ score, value: text, norm, indices }] }); } });
return results }
_searchLogical(query) { { throw new Error(LOGICAL_SEARCH_UNAVAILABLE) } }
_searchObjectList(query) { const searcher = createSearcher(query, this.options); const { keys, records } = this._myIndex; const results = [];
// List is Array<Object> records.forEach(({ $: item, i: idx }) => { if (!isDefined(item)) { return }
let matches = [];
// Iterate over every key (i.e, path), and fetch the value at that key keys.forEach((key, keyIndex) => { matches.push( ...this._findMatches({ key, value: item[keyIndex], searcher }) ); });
if (matches.length) { results.push({ idx, item, matches }); } });
return results } _findMatches({ key, value, searcher }) { if (!isDefined(value)) { return [] }
let matches = [];
if (isArray(value)) { value.forEach(({ v: text, i: idx, n: norm }) => { if (!isDefined(text)) { return }
const { isMatch, score, indices } = searcher.searchIn(text);
if (isMatch) { matches.push({ score, key, value: text, idx, norm, indices }); } }); } else { const { v: text, n: norm } = value;
const { isMatch, score, indices } = searcher.searchIn(text);
if (isMatch) { matches.push({ score, key, value: text, norm, indices }); } }
return matches }}
// Practical scoring functionfunction computeScore$1(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) { results.forEach((result) => { let totalScore = 1;
result.matches.forEach(({ key, norm, score }) => { const weight = key ? key.weight : null;
totalScore *= Math.pow( score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm) ); });
result.score = totalScore; });}
function format( results, docs, { includeMatches = Config.includeMatches, includeScore = Config.includeScore } = {}) { const transformers = [];
if (includeMatches) transformers.push(transformMatches); if (includeScore) transformers.push(transformScore);
return results.map((result) => { const { idx } = result;
const data = { item: docs[idx], refIndex: idx };
if (transformers.length) { transformers.forEach((transformer) => { transformer(result, data); }); }
return data })}
Fuse.version = '6.4.1';Fuse.createIndex = createIndex;Fuse.parseIndex = parseIndex;Fuse.config = Config;
{ Fuse.parseQuery = parse;}
export default Fuse;