diff --git a/Commons/FuzzySort.qml b/Commons/FuzzySort.qml new file mode 100644 index 000000000..334c679c1 --- /dev/null +++ b/Commons/FuzzySort.qml @@ -0,0 +1,730 @@ +pragma Singleton + +import QtQuick +import Quickshell + +Singleton { + id: root + + // Public API + function go(search, targets, options) { + return _go(search, targets, options); + } + + function single(search, target) { + return _single(search, target); + } + + function highlight(result, open, close) { + if (open === undefined) open = ''; + if (close === undefined) close = ''; + return _highlight(result, open, close); + } + + function prepare(target) { + return _prepare(target); + } + + function cleanup() { + return _cleanup(); + } + + // Internal implementation + readonly property var _INFINITY: Infinity + readonly property var _NEGATIVE_INFINITY: -Infinity + readonly property var _NULL: null + property var _noResults: { let r = []; r.total = 0; return r; } + property var _noTarget: _prepare('') + + property var _preparedCache: new Map() + property var _preparedSearchCache: new Map() + + property var _matchesSimple: [] + property var _matchesStrict: [] + property var _nextBeginningIndexesChanges: [] + property var _keysSpacesBestScores: [] + property var _allowPartialMatchScores: [] + property var _tmpTargets: [] + property var _tmpResults: [] + property var _q: _fastpriorityqueue() + + function _fastpriorityqueue() { + var e = [], o = 0, a = {}; + var v = function(r) { + for (var a = 0, vc = e[a], c = 1; c < o;) { + var s = c + 1; + a = c; + if (s < o && e[s]._score < e[c]._score) a = s; + e[a - 1 >> 1] = e[a]; + c = 1 + (a << 1); + } + for (var f = a - 1 >> 1; a > 0 && vc._score < e[f]._score; f = (a = f) - 1 >> 1) + e[a] = e[f]; + e[a] = vc; + }; + a.add = function(r) { + var ac = o; + e[o++] = r; + for (var vc = ac - 1 >> 1; ac > 0 && r._score < e[vc]._score; vc = (ac = vc) - 1 >> 1) + e[ac] = e[vc]; + e[ac] = r; + }; + a.poll = function() { + if (o !== 0) { + var ac = e[0]; + e[0] = e[--o]; + v(); + return ac; + } + }; + a.peek = function() { + if (o !== 0) return e[0]; + }; + a.replaceTop = function(r) { + e[0] = r; + v(); + }; + return a; + } + + function _createResult() { + return { + target: '', + obj: _NULL, + _score: _NEGATIVE_INFINITY, + _indexes: [], + _targetLower: '', + _targetLowerCodes: _NULL, + _nextBeginningIndexes: _NULL, + _bitflags: 0, + get indexes() { return this._indexes.slice(0, this._indexes.len).sort((a, b) => a - b); }, + set indexes(idx) { this._indexes = idx; }, + highlight: function(open, close) { return root._highlight(this, open, close); }, + get score() { return root._normalizeScore(this._score); }, + set score(s) { this._score = root._denormalizeScore(s); } + }; + } + + function _createKeysResult(len) { + var arr = new Array(len); + arr._score = _NEGATIVE_INFINITY; + arr.obj = _NULL; + Object.defineProperty(arr, 'score', { + get: function() { return root._normalizeScore(this._score); }, + set: function(s) { this._score = root._denormalizeScore(s); } + }); + return arr; + } + + function _new_result(target, options) { + var result = _createResult(); + result.target = target; + result.obj = options.obj ?? _NULL; + result._score = options._score ?? _NEGATIVE_INFINITY; + result._indexes = options._indexes ?? []; + result._targetLower = options._targetLower ?? ''; + result._targetLowerCodes = options._targetLowerCodes ?? _NULL; + result._nextBeginningIndexes = options._nextBeginningIndexes ?? _NULL; + result._bitflags = options._bitflags ?? 0; + return result; + } + + function _normalizeScore(score) { + if (score === _NEGATIVE_INFINITY) return 0; + if (score > 1) return score; + return Math.E ** (((-score + 1) ** 0.04307 - 1) * -2); + } + + function _denormalizeScore(normalizedScore) { + if (normalizedScore === 0) return _NEGATIVE_INFINITY; + if (normalizedScore > 1) return normalizedScore; + return 1 - Math.pow((Math.log(normalizedScore) / -2 + 1), 1 / 0.04307); + } + + function _remove_accents(str) { + return str.replace(/\p{Script=Latin}+/gu, match => match.normalize('NFD')).replace(/[\u0300-\u036f]/g, ''); + } + + function _prepareLowerInfo(str) { + str = _remove_accents(str); + var strLen = str.length; + var lower = str.toLowerCase(); + var lowerCodes = []; + var bitflags = 0; + var containsSpace = false; + + for (var i = 0; i < strLen; ++i) { + var lowerCode = lowerCodes[i] = lower.charCodeAt(i); + if (lowerCode === 32) { + containsSpace = true; + continue; + } + var bit = lowerCode >= 97 && lowerCode <= 122 ? lowerCode - 97 + : lowerCode >= 48 && lowerCode <= 57 ? 26 + : lowerCode <= 127 ? 30 : 31; + bitflags |= 1 << bit; + } + return { lowerCodes: lowerCodes, bitflags: bitflags, containsSpace: containsSpace, _lower: lower }; + } + + function _prepareBeginningIndexes(target) { + var targetLen = target.length; + var beginningIndexes = []; + var beginningIndexesLen = 0; + var wasUpper = false; + var wasAlphanum = false; + for (var i = 0; i < targetLen; ++i) { + var targetCode = target.charCodeAt(i); + var isUpper = targetCode >= 65 && targetCode <= 90; + var isAlphanum = isUpper || targetCode >= 97 && targetCode <= 122 || targetCode >= 48 && targetCode <= 57; + var isBeginning = isUpper && !wasUpper || !wasAlphanum || !isAlphanum; + wasUpper = isUpper; + wasAlphanum = isAlphanum; + if (isBeginning) beginningIndexes[beginningIndexesLen++] = i; + } + return beginningIndexes; + } + + function _prepareNextBeginningIndexes(target) { + target = _remove_accents(target); + var targetLen = target.length; + var beginningIndexes = _prepareBeginningIndexes(target); + var nextBeginningIndexes = []; + var lastIsBeginning = beginningIndexes[0]; + var lastIsBeginningI = 0; + for (var i = 0; i < targetLen; ++i) { + if (lastIsBeginning > i) { + nextBeginningIndexes[i] = lastIsBeginning; + } else { + lastIsBeginning = beginningIndexes[++lastIsBeginningI]; + nextBeginningIndexes[i] = lastIsBeginning === undefined ? targetLen : lastIsBeginning; + } + } + return nextBeginningIndexes; + } + + function _prepareSearch(search) { + if (typeof search === 'number') search = '' + search; + else if (typeof search !== 'string') search = ''; + search = search.trim(); + var info = _prepareLowerInfo(search); + + var spaceSearches = []; + if (info.containsSpace) { + var searches = search.split(/\s+/); + searches = [...new Set(searches)]; + for (var i = 0; i < searches.length; i++) { + if (searches[i] === '') continue; + var _info = _prepareLowerInfo(searches[i]); + spaceSearches.push({ lowerCodes: _info.lowerCodes, _lower: searches[i].toLowerCase(), containsSpace: false }); + } + } + return { lowerCodes: info.lowerCodes, _lower: info._lower, containsSpace: info.containsSpace, bitflags: info.bitflags, spaceSearches: spaceSearches }; + } + + function _prepare(target) { + if (typeof target === 'number') target = '' + target; + else if (typeof target !== 'string') target = ''; + var info = _prepareLowerInfo(target); + return _new_result(target, { _targetLower: info._lower, _targetLowerCodes: info.lowerCodes, _bitflags: info.bitflags }); + } + + function _cleanup() { + _preparedCache.clear(); + _preparedSearchCache.clear(); + } + + function _isPrepared(x) { + return typeof x === 'object' && typeof x._bitflags === 'number'; + } + + function _getPrepared(target) { + if (target.length > 999) return _prepare(target); + var targetPrepared = _preparedCache.get(target); + if (targetPrepared !== undefined) return targetPrepared; + targetPrepared = _prepare(target); + _preparedCache.set(target, targetPrepared); + return targetPrepared; + } + + function _getPreparedSearch(search) { + if (search.length > 999) return _prepareSearch(search); + var searchPrepared = _preparedSearchCache.get(search); + if (searchPrepared !== undefined) return searchPrepared; + searchPrepared = _prepareSearch(search); + _preparedSearchCache.set(search, searchPrepared); + return searchPrepared; + } + + function _getValue(obj, prop) { + var tmp = obj[prop]; + if (tmp !== undefined) return tmp; + if (typeof prop === 'function') return prop(obj); + var segs = prop; + if (!Array.isArray(prop)) segs = prop.split('.'); + var len = segs.length; + var i = -1; + while (obj && (++i < len)) obj = obj[segs[i]]; + return obj; + } + + function _single(search, target) { + if (!search || !target) return _NULL; + var preparedSearch = _getPreparedSearch(search); + if (!_isPrepared(target)) target = _getPrepared(target); + var searchBitflags = preparedSearch.bitflags; + if ((searchBitflags & target._bitflags) !== searchBitflags) return _NULL; + return _algorithm(preparedSearch, target); + } + + function _highlight(result, open, close) { + if (open === undefined) open = ''; + if (close === undefined) close = ''; + var callback = typeof open === 'function' ? open : undefined; + + var target = result.target; + var targetLen = target.length; + var indexes = result.indexes; + var highlighted = ''; + var matchI = 0; + var indexesI = 0; + var opened = false; + var parts = []; + + for (var i = 0; i < targetLen; ++i) { + var ch = target[i]; + if (indexes[indexesI] === i) { + ++indexesI; + if (!opened) { + opened = true; + if (callback) { + parts.push(highlighted); + highlighted = ''; + } else { + highlighted += open; + } + } + if (indexesI === indexes.length) { + if (callback) { + highlighted += ch; + parts.push(callback(highlighted, matchI++)); + highlighted = ''; + parts.push(target.substr(i + 1)); + } else { + highlighted += ch + close + target.substr(i + 1); + } + break; + } + } else { + if (opened) { + opened = false; + if (callback) { + parts.push(callback(highlighted, matchI++)); + highlighted = ''; + } else { + highlighted += close; + } + } + } + highlighted += ch; + } + return callback ? parts : highlighted; + } + + function _all(targets, options) { + var results = []; + results.total = targets.length; + var limit = options?.limit || _INFINITY; + + if (options?.key) { + for (var i = 0; i < targets.length; i++) { + var obj = targets[i]; + var target = _getValue(obj, options.key); + if (target == _NULL) continue; + if (!_isPrepared(target)) target = _getPrepared(target); + var result = _new_result(target.target, { _score: target._score, obj: obj }); + results.push(result); + if (results.length >= limit) return results; + } + } else if (options?.keys) { + for (var i = 0; i < targets.length; i++) { + var obj = targets[i]; + var objResults = _createKeysResult(options.keys.length); + for (var keyI = options.keys.length - 1; keyI >= 0; --keyI) { + var target = _getValue(obj, options.keys[keyI]); + if (!target) { objResults[keyI] = _noTarget; continue; } + if (!_isPrepared(target)) target = _getPrepared(target); + target._score = _NEGATIVE_INFINITY; + target._indexes.len = 0; + objResults[keyI] = target; + } + objResults.obj = obj; + objResults._score = _NEGATIVE_INFINITY; + results.push(objResults); + if (results.length >= limit) return results; + } + } else { + for (var i = 0; i < targets.length; i++) { + var target = targets[i]; + if (target == _NULL) continue; + if (!_isPrepared(target)) target = _getPrepared(target); + target._score = _NEGATIVE_INFINITY; + target._indexes.len = 0; + results.push(target); + if (results.length >= limit) return results; + } + } + return results; + } + + function _algorithm(preparedSearch, prepared, allowSpaces, allowPartialMatch) { + if (allowSpaces === undefined) allowSpaces = false; + if (allowPartialMatch === undefined) allowPartialMatch = false; + + if (allowSpaces === false && preparedSearch.containsSpace) + return _algorithmSpaces(preparedSearch, prepared, allowPartialMatch); + + var searchLower = preparedSearch._lower; + var searchLowerCodes = preparedSearch.lowerCodes; + var searchLowerCode = searchLowerCodes[0]; + var targetLowerCodes = prepared._targetLowerCodes; + var searchLen = searchLowerCodes.length; + var targetLen = targetLowerCodes.length; + var searchI = 0; + var targetI = 0; + var matchesSimpleLen = 0; + + for (;;) { + var isMatch = searchLowerCode === targetLowerCodes[targetI]; + if (isMatch) { + _matchesSimple[matchesSimpleLen++] = targetI; + ++searchI; + if (searchI === searchLen) break; + searchLowerCode = searchLowerCodes[searchI]; + } + ++targetI; + if (targetI >= targetLen) return _NULL; + } + + searchI = 0; + var successStrict = false; + var matchesStrictLen = 0; + + var nextBeginningIndexes = prepared._nextBeginningIndexes; + if (nextBeginningIndexes === _NULL) + nextBeginningIndexes = prepared._nextBeginningIndexes = _prepareNextBeginningIndexes(prepared.target); + targetI = _matchesSimple[0] === 0 ? 0 : nextBeginningIndexes[_matchesSimple[0] - 1]; + + var backtrackCount = 0; + if (targetI !== targetLen) for (;;) { + if (targetI >= targetLen) { + if (searchI <= 0) break; + ++backtrackCount; + if (backtrackCount > 200) break; + --searchI; + var lastMatch = _matchesStrict[--matchesStrictLen]; + targetI = nextBeginningIndexes[lastMatch]; + } else { + var isMatch = searchLowerCodes[searchI] === targetLowerCodes[targetI]; + if (isMatch) { + _matchesStrict[matchesStrictLen++] = targetI; + ++searchI; + if (searchI === searchLen) { successStrict = true; break; } + ++targetI; + } else { + targetI = nextBeginningIndexes[targetI]; + } + } + } + + var substringIndex = searchLen <= 1 ? -1 : prepared._targetLower.indexOf(searchLower, _matchesSimple[0]); + var isSubstring = !!~substringIndex; + var isSubstringBeginning = !isSubstring ? false : substringIndex === 0 || prepared._nextBeginningIndexes[substringIndex - 1] === substringIndex; + + if (isSubstring && !isSubstringBeginning) { + for (var i = 0; i < nextBeginningIndexes.length; i = nextBeginningIndexes[i]) { + if (i <= substringIndex) continue; + for (var s = 0; s < searchLen; s++) + if (searchLowerCodes[s] !== prepared._targetLowerCodes[i + s]) break; + if (s === searchLen) { substringIndex = i; isSubstringBeginning = true; break; } + } + } + + var calculateScore = function(matches) { + var score = 0; + var extraMatchGroupCount = 0; + for (var i = 1; i < searchLen; ++i) { + if (matches[i] - matches[i - 1] !== 1) { score -= matches[i]; ++extraMatchGroupCount; } + } + var unmatchedDistance = matches[searchLen - 1] - matches[0] - (searchLen - 1); + score -= (12 + unmatchedDistance) * extraMatchGroupCount; + if (matches[0] !== 0) score -= matches[0] * matches[0] * 0.2; + if (!successStrict) { + score *= 1000; + } else { + var uniqueBeginningIndexes = 1; + for (var i = nextBeginningIndexes[0]; i < targetLen; i = nextBeginningIndexes[i]) ++uniqueBeginningIndexes; + if (uniqueBeginningIndexes > 24) score *= (uniqueBeginningIndexes - 24) * 10; + } + score -= (targetLen - searchLen) / 2; + if (isSubstring) score /= 1 + searchLen * searchLen * 1; + if (isSubstringBeginning) score /= 1 + searchLen * searchLen * 1; + score -= (targetLen - searchLen) / 2; + return score; + }; + + var matchesBest, score; + if (!successStrict) { + if (isSubstring) for (var i = 0; i < searchLen; ++i) _matchesSimple[i] = substringIndex + i; + matchesBest = _matchesSimple; + score = calculateScore(matchesBest); + } else { + if (isSubstringBeginning) { + for (var i = 0; i < searchLen; ++i) _matchesSimple[i] = substringIndex + i; + matchesBest = _matchesSimple; + score = calculateScore(_matchesSimple); + } else { + matchesBest = _matchesStrict; + score = calculateScore(_matchesStrict); + } + } + + prepared._score = score; + for (var i = 0; i < searchLen; ++i) prepared._indexes[i] = matchesBest[i]; + prepared._indexes.len = searchLen; + + var result = _createResult(); + result.target = prepared.target; + result._score = prepared._score; + result._indexes = prepared._indexes; + return result; + } + + function _algorithmSpaces(preparedSearch, target, allowPartialMatch) { + var seen_indexes = new Set(); + var score = 0; + var result = _NULL; + + var first_seen_index_last_search = 0; + var searches = preparedSearch.spaceSearches; + var searchesLen = searches.length; + var changeslen = 0; + + var resetNextBeginningIndexes = function() { + for (let i = changeslen - 1; i >= 0; i--) + target._nextBeginningIndexes[_nextBeginningIndexesChanges[i * 2 + 0]] = _nextBeginningIndexesChanges[i * 2 + 1]; + }; + + var hasAtLeast1Match = false; + for (var i = 0; i < searchesLen; ++i) { + _allowPartialMatchScores[i] = _NEGATIVE_INFINITY; + var search = searches[i]; + result = _algorithm(search, target); + + if (allowPartialMatch) { + if (result === _NULL) continue; + hasAtLeast1Match = true; + } else { + if (result === _NULL) { resetNextBeginningIndexes(); return _NULL; } + } + + var isTheLastSearch = i === searchesLen - 1; + if (!isTheLastSearch) { + var indexes = result._indexes; + var indexesIsConsecutiveSubstring = true; + for (let j = 0; j < indexes.len - 1; j++) { + if (indexes[j + 1] - indexes[j] !== 1) { + indexesIsConsecutiveSubstring = false; + break; + } + } + + if (indexesIsConsecutiveSubstring) { + var newBeginningIndex = indexes[indexes.len - 1] + 1; + var toReplace = target._nextBeginningIndexes[newBeginningIndex - 1]; + for (let j = newBeginningIndex - 1; j >= 0; j--) { + if (toReplace !== target._nextBeginningIndexes[j]) break; + target._nextBeginningIndexes[j] = newBeginningIndex; + _nextBeginningIndexesChanges[changeslen * 2 + 0] = j; + _nextBeginningIndexesChanges[changeslen * 2 + 1] = toReplace; + changeslen++; + } + } + } + + score += result._score / searchesLen; + _allowPartialMatchScores[i] = result._score / searchesLen; + + if (result._indexes[0] < first_seen_index_last_search) { + score -= (first_seen_index_last_search - result._indexes[0]) * 2; + } + first_seen_index_last_search = result._indexes[0]; + + for (var j = 0; j < result._indexes.len; ++j) seen_indexes.add(result._indexes[j]); + } + + if (allowPartialMatch && !hasAtLeast1Match) return _NULL; + + resetNextBeginningIndexes(); + + var allowSpacesResult = _algorithm(preparedSearch, target, true); + if (allowSpacesResult !== _NULL && allowSpacesResult._score > score) { + if (allowPartialMatch) { + for (var i = 0; i < searchesLen; ++i) { + _allowPartialMatchScores[i] = allowSpacesResult._score / searchesLen; + } + } + return allowSpacesResult; + } + + if (allowPartialMatch) result = target; + result._score = score; + + var idx = 0; + for (let index of seen_indexes) result._indexes[idx++] = index; + result._indexes.len = idx; + + return result; + } + + function _go(search, targets, options) { + if (!search) return options?.all ? _all(targets, options) : _noResults; + + var preparedSearch = _getPreparedSearch(search); + var searchBitflags = preparedSearch.bitflags; + var containsSpace = preparedSearch.containsSpace; + + var threshold = _denormalizeScore(options?.threshold || 0); + var limit = options?.limit || _INFINITY; + + var resultsLen = 0; + var limitedCount = 0; + var targetsLen = targets.length; + + function push_result(result) { + if (resultsLen < limit) { _q.add(result); ++resultsLen; } + else { + ++limitedCount; + if (result._score > _q.peek()._score) _q.replaceTop(result); + } + } + + if (options?.key) { + var key = options.key; + for (var i = 0; i < targetsLen; ++i) { + var obj = targets[i]; + var target = _getValue(obj, key); + if (!target) continue; + if (!_isPrepared(target)) target = _getPrepared(target); + if ((searchBitflags & target._bitflags) !== searchBitflags) continue; + var result = _algorithm(preparedSearch, target); + if (result === _NULL) continue; + if (result._score < threshold) continue; + result.obj = obj; + push_result(result); + } + } else if (options?.keys) { + var keys = options.keys; + var keysLen = keys.length; + + outer: for (var i = 0; i < targetsLen; ++i) { + var obj = targets[i]; + var keysBitflags = 0; + for (var keyI = 0; keyI < keysLen; ++keyI) { + var key = keys[keyI]; + var target = _getValue(obj, key); + if (!target) { _tmpTargets[keyI] = _noTarget; continue; } + if (!_isPrepared(target)) target = _getPrepared(target); + _tmpTargets[keyI] = target; + keysBitflags |= target._bitflags; + } + + if ((searchBitflags & keysBitflags) !== searchBitflags) continue; + + if (containsSpace) + for (let j = 0; j < preparedSearch.spaceSearches.length; j++) + _keysSpacesBestScores[j] = _NEGATIVE_INFINITY; + + for (var keyI = 0; keyI < keysLen; ++keyI) { + target = _tmpTargets[keyI]; + if (target === _noTarget) { _tmpResults[keyI] = _noTarget; continue; } + + _tmpResults[keyI] = _algorithm(preparedSearch, target, false, containsSpace); + if (_tmpResults[keyI] === _NULL) { _tmpResults[keyI] = _noTarget; continue; } + + if (containsSpace) for (let j = 0; j < preparedSearch.spaceSearches.length; j++) { + if (_allowPartialMatchScores[j] > -1000) { + if (_keysSpacesBestScores[j] > _NEGATIVE_INFINITY) { + var tmp = (_keysSpacesBestScores[j] + _allowPartialMatchScores[j]) / 4; + if (tmp > _keysSpacesBestScores[j]) _keysSpacesBestScores[j] = tmp; + } + } + if (_allowPartialMatchScores[j] > _keysSpacesBestScores[j]) + _keysSpacesBestScores[j] = _allowPartialMatchScores[j]; + } + } + + if (containsSpace) { + for (let j = 0; j < preparedSearch.spaceSearches.length; j++) + if (_keysSpacesBestScores[j] === _NEGATIVE_INFINITY) continue outer; + } else { + var hasAtLeast1Match = false; + for (let j = 0; j < keysLen; j++) + if (_tmpResults[j]._score !== _NEGATIVE_INFINITY) { hasAtLeast1Match = true; break; } + if (!hasAtLeast1Match) continue; + } + + var objResults = _createKeysResult(keysLen); + for (let j = 0; j < keysLen; j++) objResults[j] = _tmpResults[j]; + + var score; + if (containsSpace) { + score = 0; + for (let j = 0; j < preparedSearch.spaceSearches.length; j++) score += _keysSpacesBestScores[j]; + } else { + score = _NEGATIVE_INFINITY; + for (let j = 0; j < keysLen; j++) { + var res = objResults[j]; + if (res._score > -1000) { + if (score > _NEGATIVE_INFINITY) { + var tmp = (score + res._score) / 4; + if (tmp > score) score = tmp; + } + } + if (res._score > score) score = res._score; + } + } + + objResults.obj = obj; + objResults._score = score; + + if (options?.scoreFn) { + score = options.scoreFn(objResults); + if (!score) continue; + score = _denormalizeScore(score); + objResults._score = score; + } + + if (score < threshold) continue; + push_result(objResults); + } + } else { + for (var i = 0; i < targetsLen; ++i) { + var target = targets[i]; + if (!target) continue; + if (!_isPrepared(target)) target = _getPrepared(target); + if ((searchBitflags & target._bitflags) !== searchBitflags) continue; + var result = _algorithm(preparedSearch, target); + if (result === _NULL) continue; + if (result._score < threshold) continue; + push_result(result); + } + } + + if (resultsLen === 0) return _noResults; + var results = new Array(resultsLen); + for (var i = resultsLen - 1; i >= 0; --i) results[i] = _q.poll(); + results.total = resultsLen + limitedCount; + return results; + } +} diff --git a/Commons/ThemeIcons.qml b/Commons/ThemeIcons.qml index 45053d5cb..f4dc67d4d 100644 --- a/Commons/ThemeIcons.qml +++ b/Commons/ThemeIcons.qml @@ -2,7 +2,7 @@ pragma Singleton import QtQuick import Quickshell -import "../Helpers/FuzzySort.js" as FuzzySort +import qs.Commons Singleton { id: root diff --git a/Helpers/FuzzySort.js b/Helpers/FuzzySort.js deleted file mode 100644 index 0e1f68be9..000000000 --- a/Helpers/FuzzySort.js +++ /dev/null @@ -1,678 +0,0 @@ -.pragma library - -var single = (search, target) => { - if(!search || !target) return NULL - - var preparedSearch = getPreparedSearch(search) - if(!isPrepared(target)) target = getPrepared(target) - - var searchBitflags = preparedSearch.bitflags - if((searchBitflags & target._bitflags) !== searchBitflags) return NULL - - return algorithm(preparedSearch, target) -} - -var go = (search, targets, options) => { - if(!search) return options?.all ? all(targets, options) : noResults - - var preparedSearch = getPreparedSearch(search) - var searchBitflags = preparedSearch.bitflags - var containsSpace = preparedSearch.containsSpace - - var threshold = denormalizeScore( options?.threshold || 0 ) - var limit = options?.limit || INFINITY - - var resultsLen = 0; var limitedCount = 0 - var targetsLen = targets.length - - function push_result(result) { - if(resultsLen < limit) { q.add(result); ++resultsLen } - else { - ++limitedCount - if(result._score > q.peek()._score) q.replaceTop(result) - } - } - - // This code is copy/pasted 3 times for performance reasons [options.key, options.keys, no keys] - - // options.key - if(options?.key) { - var key = options.key - for(var i = 0; i < targetsLen; ++i) { var obj = targets[i] - var target = getValue(obj, key) - if(!target) continue - if(!isPrepared(target)) target = getPrepared(target) - - if((searchBitflags & target._bitflags) !== searchBitflags) continue - var result = algorithm(preparedSearch, target) - if(result === NULL) continue - if(result._score < threshold) continue - - result.obj = obj - push_result(result) - } - - // options.keys - } else if(options?.keys) { - var keys = options.keys - var keysLen = keys.length - - outer: for(var i = 0; i < targetsLen; ++i) { var obj = targets[i] - - { // early out based on bitflags - var keysBitflags = 0 - for (var keyI = 0; keyI < keysLen; ++keyI) { - var key = keys[keyI] - var target = getValue(obj, key) - if(!target) { tmpTargets[keyI] = noTarget; continue } - if(!isPrepared(target)) target = getPrepared(target) - tmpTargets[keyI] = target - - keysBitflags |= target._bitflags - } - - if((searchBitflags & keysBitflags) !== searchBitflags) continue - } - - if(containsSpace) for(let i=0; i -1000) { - if(keysSpacesBestScores[i] > NEGATIVE_INFINITY) { - var tmp = (keysSpacesBestScores[i] + allowPartialMatchScores[i]) / 4/*bonus score for having multiple matches*/ - if(tmp > keysSpacesBestScores[i]) keysSpacesBestScores[i] = tmp - } - } - if(allowPartialMatchScores[i] > keysSpacesBestScores[i]) keysSpacesBestScores[i] = allowPartialMatchScores[i] - } - } - - if(containsSpace) { - for(let i=0; i -1000) { - if(score > NEGATIVE_INFINITY) { - var tmp = (score + result._score) / 4/*bonus score for having multiple matches*/ - if(tmp > score) score = tmp - } - } - if(result._score > score) score = result._score - } - } - - objResults.obj = obj - objResults._score = score - if(options?.scoreFn) { - score = options.scoreFn(objResults) - if(!score) continue - score = denormalizeScore(score) - objResults._score = score - } - - if(score < threshold) continue - push_result(objResults) - } - - // no keys - } else { - for(var i = 0; i < targetsLen; ++i) { var target = targets[i] - if(!target) continue - if(!isPrepared(target)) target = getPrepared(target) - - if((searchBitflags & target._bitflags) !== searchBitflags) continue - var result = algorithm(preparedSearch, target) - if(result === NULL) continue - if(result._score < threshold) continue - - push_result(result) - } - } - - if(resultsLen === 0) return noResults - var results = new Array(resultsLen) - for(var i = resultsLen - 1; i >= 0; --i) results[i] = q.poll() - results.total = resultsLen + limitedCount - return results -} - - -// this is written as 1 function instead of 2 for minification. perf seems fine ... -// except when minified. the perf is very slow -var highlight = (result, open='', close='') => { - var callback = typeof open === 'function' ? open : undefined - - var target = result.target - var targetLen = target.length - var indexes = result.indexes - var highlighted = '' - var matchI = 0 - var indexesI = 0 - var opened = false - var parts = [] - - for(var i = 0; i < targetLen; ++i) { var char = target[i] - if(indexes[indexesI] === i) { - ++indexesI - if(!opened) { opened = true - if(callback) { - parts.push(highlighted); highlighted = '' - } else { - highlighted += open - } - } - - if(indexesI === indexes.length) { - if(callback) { - highlighted += char - parts.push(callback(highlighted, matchI++)); highlighted = '' - parts.push(target.substr(i+1)) - } else { - highlighted += char + close + target.substr(i+1) - } - break - } - } else { - if(opened) { opened = false - if(callback) { - parts.push(callback(highlighted, matchI++)); highlighted = '' - } else { - highlighted += close - } - } - } - highlighted += char - } - - return callback ? parts : highlighted -} - - -var prepare = (target) => { - if(typeof target === 'number') target = ''+target - else if(typeof target !== 'string') target = '' - var info = prepareLowerInfo(target) - return new_result(target, {_targetLower:info._lower, _targetLowerCodes:info.lowerCodes, _bitflags:info.bitflags}) -} - -var cleanup = () => { preparedCache.clear(); preparedSearchCache.clear() } - - -// Below this point is only internal code -// Below this point is only internal code -// Below this point is only internal code -// Below this point is only internal code - - -class Result { - get ['indexes']() { return this._indexes.slice(0, this._indexes.len).sort((a,b)=>a-b) } - set ['indexes'](indexes) { return this._indexes = indexes } - ['highlight'](open, close) { return highlight(this, open, close) } - get ['score']() { return normalizeScore(this._score) } - set ['score'](score) { this._score = denormalizeScore(score) } -} - -class KeysResult extends Array { - get ['score']() { return normalizeScore(this._score) } - set ['score'](score) { this._score = denormalizeScore(score) } -} - -var new_result = (target, options) => { - const result = new Result() - result['target'] = target - result['obj'] = options.obj ?? NULL - result._score = options._score ?? NEGATIVE_INFINITY - result._indexes = options._indexes ?? [] - result._targetLower = options._targetLower ?? '' - result._targetLowerCodes = options._targetLowerCodes ?? NULL - result._nextBeginningIndexes = options._nextBeginningIndexes ?? NULL - result._bitflags = options._bitflags ?? 0 - return result -} - - -var normalizeScore = score => { - if(score === NEGATIVE_INFINITY) return 0 - if(score > 1) return score - return Math.E ** ( ((-score + 1)**.04307 - 1) * -2) -} -var denormalizeScore = normalizedScore => { - if(normalizedScore === 0) return NEGATIVE_INFINITY - if(normalizedScore > 1) return normalizedScore - return 1 - Math.pow((Math.log(normalizedScore) / -2 + 1), 1 / 0.04307) -} - - -var prepareSearch = (search) => { - if(typeof search === 'number') search = ''+search - else if(typeof search !== 'string') search = '' - search = search.trim() - var info = prepareLowerInfo(search) - - var spaceSearches = [] - if(info.containsSpace) { - var searches = search.split(/\s+/) - searches = [...new Set(searches)] // distinct - for(var i=0; i { - if(target.length > 999) return prepare(target) // don't cache huge targets - var targetPrepared = preparedCache.get(target) - if(targetPrepared !== undefined) return targetPrepared - targetPrepared = prepare(target) - preparedCache.set(target, targetPrepared) - return targetPrepared -} -var getPreparedSearch = (search) => { - if(search.length > 999) return prepareSearch(search) // don't cache huge searches - var searchPrepared = preparedSearchCache.get(search) - if(searchPrepared !== undefined) return searchPrepared - searchPrepared = prepareSearch(search) - preparedSearchCache.set(search, searchPrepared) - return searchPrepared -} - - -var all = (targets, options) => { - var results = []; results.total = targets.length // this total can be wrong if some targets are skipped - - var limit = options?.limit || INFINITY - - if(options?.key) { - for(var i=0;i= limit) return results - } - } else if(options?.keys) { - for(var i=0;i= 0; --keyI) { - var target = getValue(obj, options.keys[keyI]) - if(!target) { objResults[keyI] = noTarget; continue } - if(!isPrepared(target)) target = getPrepared(target) - target._score = NEGATIVE_INFINITY - target._indexes.len = 0 - objResults[keyI] = target - } - objResults.obj = obj - objResults._score = NEGATIVE_INFINITY - results.push(objResults); if(results.length >= limit) return results - } - } else { - for(var i=0;i= limit) return results - } - } - - return results -} - - -var algorithm = (preparedSearch, prepared, allowSpaces=false, allowPartialMatch=false) => { - if(allowSpaces===false && preparedSearch.containsSpace) return algorithmSpaces(preparedSearch, prepared, allowPartialMatch) - - var searchLower = preparedSearch._lower - var searchLowerCodes = preparedSearch.lowerCodes - var searchLowerCode = searchLowerCodes[0] - var targetLowerCodes = prepared._targetLowerCodes - var searchLen = searchLowerCodes.length - var targetLen = targetLowerCodes.length - var searchI = 0 // where we at - var targetI = 0 // where you at - var matchesSimpleLen = 0 - - // very basic fuzzy match; to remove non-matching targets ASAP! - // walk through target. find sequential matches. - // if all chars aren't found then exit - for(;;) { - var isMatch = searchLowerCode === targetLowerCodes[targetI] - if(isMatch) { - matchesSimple[matchesSimpleLen++] = targetI - ++searchI; if(searchI === searchLen) break - searchLowerCode = searchLowerCodes[searchI] - } - ++targetI; if(targetI >= targetLen) return NULL // Failed to find searchI - } - - var searchI = 0 - var successStrict = false - var matchesStrictLen = 0 - - var nextBeginningIndexes = prepared._nextBeginningIndexes - if(nextBeginningIndexes === NULL) nextBeginningIndexes = prepared._nextBeginningIndexes = prepareNextBeginningIndexes(prepared.target) - targetI = matchesSimple[0]===0 ? 0 : nextBeginningIndexes[matchesSimple[0]-1] - - // Our target string successfully matched all characters in sequence! - // Let's try a more advanced and strict test to improve the score - // only count it as a match if it's consecutive or a beginning character! - var backtrackCount = 0 - if(targetI !== targetLen) for(;;) { - if(targetI >= targetLen) { - // We failed to find a good spot for this search char, go back to the previous search char and force it forward - if(searchI <= 0) break // We failed to push chars forward for a better match - - ++backtrackCount; if(backtrackCount > 200) break // exponential backtracking is taking too long, just give up and return a bad match - - --searchI - var lastMatch = matchesStrict[--matchesStrictLen] - targetI = nextBeginningIndexes[lastMatch] - - } else { - var isMatch = searchLowerCodes[searchI] === targetLowerCodes[targetI] - if(isMatch) { - matchesStrict[matchesStrictLen++] = targetI - ++searchI; if(searchI === searchLen) { successStrict = true; break } - ++targetI - } else { - targetI = nextBeginningIndexes[targetI] - } - } - } - - // check if it's a substring match - var substringIndex = searchLen <= 1 ? -1 : prepared._targetLower.indexOf(searchLower, matchesSimple[0]) // perf: this is slow - var isSubstring = !!~substringIndex - var isSubstringBeginning = !isSubstring ? false : substringIndex===0 || prepared._nextBeginningIndexes[substringIndex-1] === substringIndex - - // if it's a substring match but not at a beginning index, let's try to find a substring starting at a beginning index for a better score - if(isSubstring && !isSubstringBeginning) { - for(var i=0; i { - var score = 0 - - var extraMatchGroupCount = 0 - for(var i = 1; i < searchLen; ++i) { - if(matches[i] - matches[i-1] !== 1) {score -= matches[i]; ++extraMatchGroupCount} - } - var unmatchedDistance = matches[searchLen-1] - matches[0] - (searchLen-1) - - score -= (12+unmatchedDistance) * extraMatchGroupCount // penality for more groups - - if(matches[0] !== 0) score -= matches[0]*matches[0]*.2 // penality for not starting near the beginning - - if(!successStrict) { - score *= 1000 - } else { - // successStrict on a target with too many beginning indexes loses points for being a bad target - var uniqueBeginningIndexes = 1 - for(var i = nextBeginningIndexes[0]; i < targetLen; i=nextBeginningIndexes[i]) ++uniqueBeginningIndexes - - if(uniqueBeginningIndexes > 24) score *= (uniqueBeginningIndexes-24)*10 // quite arbitrary numbers here ... - } - - score -= (targetLen - searchLen)/2 // penality for longer targets - - if(isSubstring) score /= 1+searchLen*searchLen*1 // bonus for being a full substring - if(isSubstringBeginning) score /= 1+searchLen*searchLen*1 // bonus for substring starting on a beginningIndex - - score -= (targetLen - searchLen)/2 // penality for longer targets - - return score - } - - if(!successStrict) { - if(isSubstring) for(var i=0; i { - var seen_indexes = new Set() - var score = 0 - var result = NULL - - var first_seen_index_last_search = 0 - var searches = preparedSearch.spaceSearches - var searchesLen = searches.length - var changeslen = 0 - - // Return _nextBeginningIndexes back to its normal state - var resetNextBeginningIndexes = () => { - for(let i=changeslen-1; i>=0; i--) target._nextBeginningIndexes[nextBeginningIndexesChanges[i*2 + 0]] = nextBeginningIndexesChanges[i*2 + 1] - } - - var hasAtLeast1Match = false - for(var i=0; i=0; i--) { - if(toReplace !== target._nextBeginningIndexes[i]) break - target._nextBeginningIndexes[i] = newBeginningIndex - nextBeginningIndexesChanges[changeslen*2 + 0] = i - nextBeginningIndexesChanges[changeslen*2 + 1] = toReplace - changeslen++ - } - } - } - - score += result._score / searchesLen - allowPartialMatchScores[i] = result._score / searchesLen - - // dock points based on order otherwise "c man" returns Manifest.cpp instead of CheatManager.h - if(result._indexes[0] < first_seen_index_last_search) { - score -= (first_seen_index_last_search - result._indexes[0]) * 2 - } - first_seen_index_last_search = result._indexes[0] - - for(var j=0; j score) { - if(allowPartialMatch) { - for(var i=0; i str.replace(/\p{Script=Latin}+/gu, match => match.normalize('NFD')).replace(/[\u0300-\u036f]/g, '') - -var prepareLowerInfo = (str) => { - str = remove_accents(str) - var strLen = str.length - var lower = str.toLowerCase() - var lowerCodes = [] // new Array(strLen) sparse array is too slow - var bitflags = 0 - var containsSpace = false // space isn't stored in bitflags because of how searching with a space works - - for(var i = 0; i < strLen; ++i) { - var lowerCode = lowerCodes[i] = lower.charCodeAt(i) - - if(lowerCode === 32) { - containsSpace = true - continue // it's important that we don't set any bitflags for space - } - - var bit = lowerCode>=97&&lowerCode<=122 ? lowerCode-97 // alphabet - : lowerCode>=48&&lowerCode<=57 ? 26 // numbers - // 3 bits available - : lowerCode<=127 ? 30 // other ascii - : 31 // other utf8 - bitflags |= 1< { - var targetLen = target.length - var beginningIndexes = []; var beginningIndexesLen = 0 - var wasUpper = false - var wasAlphanum = false - for(var i = 0; i < targetLen; ++i) { - var targetCode = target.charCodeAt(i) - var isUpper = targetCode>=65&&targetCode<=90 - var isAlphanum = isUpper || targetCode>=97&&targetCode<=122 || targetCode>=48&&targetCode<=57 - var isBeginning = isUpper && !wasUpper || !wasAlphanum || !isAlphanum - wasUpper = isUpper - wasAlphanum = isAlphanum - if(isBeginning) beginningIndexes[beginningIndexesLen++] = i - } - return beginningIndexes -} -var prepareNextBeginningIndexes = (target) => { - target = remove_accents(target) - var targetLen = target.length - var beginningIndexes = prepareBeginningIndexes(target) - var nextBeginningIndexes = [] // new Array(targetLen) sparse array is too slow - var lastIsBeginning = beginningIndexes[0] - var lastIsBeginningI = 0 - for(var i = 0; i < targetLen; ++i) { - if(lastIsBeginning > i) { - nextBeginningIndexes[i] = lastIsBeginning - } else { - lastIsBeginning = beginningIndexes[++lastIsBeginningI] - nextBeginningIndexes[i] = lastIsBeginning===undefined ? targetLen : lastIsBeginning - } - } - return nextBeginningIndexes -} - -var preparedCache = new Map() -var preparedSearchCache = new Map() - -// the theory behind these being globals is to reduce garbage collection by not making new arrays -var matchesSimple = []; var matchesStrict = [] -var nextBeginningIndexesChanges = [] // allows straw berry to match strawberry well, by modifying the end of a substring to be considered a beginning index for the rest of the search -var keysSpacesBestScores = []; var allowPartialMatchScores = [] -var tmpTargets = []; var tmpResults = [] - -// prop = 'key' 2.5ms optimized for this case, seems to be about as fast as direct obj[prop] -// prop = 'key1.key2' 10ms -// prop = ['key1', 'key2'] 27ms -// prop = obj => obj.tags.join() ??ms -var getValue = (obj, prop) => { - var tmp = obj[prop]; if(tmp !== undefined) return tmp - if(typeof prop === 'function') return prop(obj) // this should run first. but that makes string props slower - var segs = prop - if(!Array.isArray(prop)) segs = prop.split('.') - var len = segs.length - var i = -1 - while (obj && (++i < len)) obj = obj[segs[i]] - return obj -} - -var isPrepared = (x) => { return typeof x === 'object' && typeof x._bitflags === 'number' } -var INFINITY = Infinity; var NEGATIVE_INFINITY = -INFINITY -var noResults = []; noResults.total = 0 -var NULL = null - -var noTarget = prepare('') - -// Hacked version of https://github.com/lemire/FastPriorityQueue.js -var fastpriorityqueue=r=>{var e=[],o=0,a={},v=r=>{for(var a=0,v=e[a],c=1;c>1]=e[a],c=1+(a<<1)}for(var f=a-1>>1;a>0&&v._score>1)e[a]=e[f];e[a]=v};return a.add=(r=>{var a=o;e[o++]=r;for(var v=a-1>>1;a>0&&r._score>1)e[a]=e[v];e[a]=r}),a.poll=(r=>{if(0!==o){var a=e[0];return e[0]=e[--o],v(),a}}),a.peek=(r=>{if(0!==o)return e[0]}),a.replaceTop=(r=>{e[0]=r,v()}),a} -var q = fastpriorityqueue() // reuse this \ No newline at end of file diff --git a/Modules/Panels/Launcher/Launcher.qml b/Modules/Panels/Launcher/Launcher.qml index d93ddf0ed..28cbfbc23 100644 --- a/Modules/Panels/Launcher/Launcher.qml +++ b/Modules/Panels/Launcher/Launcher.qml @@ -3,7 +3,6 @@ import QtQuick.Controls import QtQuick.Layouts import Quickshell import Quickshell.Widgets -import "../../../Helpers/FuzzySort.js" as Fuzzysort import "Providers" import qs.Commons @@ -420,9 +419,9 @@ SmartPanel { // Filter commands using fuzzy search when typing partial command const query = searchText.substring(1); // Remove the ">" prefix - if (typeof Fuzzysort !== 'undefined') { + if (typeof FuzzySort !== 'undefined') { // Use fuzzy search to filter commands - const fuzzyResults = Fuzzysort.go(query, allCommands, { + const fuzzyResults = FuzzySort.go(query, allCommands, { "keys": ["name"], "threshold": -1000, "limit": 50 diff --git a/Modules/Panels/Launcher/Providers/ApplicationsProvider.qml b/Modules/Panels/Launcher/Providers/ApplicationsProvider.qml index 2bb8afcbb..cfa64e364 100644 --- a/Modules/Panels/Launcher/Providers/ApplicationsProvider.qml +++ b/Modules/Panels/Launcher/Providers/ApplicationsProvider.qml @@ -1,7 +1,6 @@ import QtQuick import Quickshell import Quickshell.Io -import "../../../../Helpers/FuzzySort.js" as Fuzzysort import qs.Commons Item { @@ -475,8 +474,8 @@ Item { } // Use fuzzy search if available, fallback to simple search - if (typeof Fuzzysort !== 'undefined') { - const fuzzyResults = Fuzzysort.go(query, filteredEntries, { + if (typeof FuzzySort !== 'undefined') { + const fuzzyResults = FuzzySort.go(query, filteredEntries, { "keys": ["name", "comment", "genericName", "executableName"], "threshold": -1000, "limit": 20 diff --git a/Modules/Panels/Settings/Tabs/Plugins/AvailableSubTab.qml b/Modules/Panels/Settings/Tabs/Plugins/AvailableSubTab.qml index 0f8bac6ce..3a5b3177c 100644 --- a/Modules/Panels/Settings/Tabs/Plugins/AvailableSubTab.qml +++ b/Modules/Panels/Settings/Tabs/Plugins/AvailableSubTab.qml @@ -1,7 +1,6 @@ import QtQuick import QtQuick.Controls import QtQuick.Layouts -import "../../../../../Helpers/FuzzySort.js" as Fuzzysort import qs.Commons import qs.Services.Noctalia import qs.Services.UI @@ -189,7 +188,7 @@ ColumnLayout { // Then apply fuzzy search if there's search text var query = root.pluginSearchText.trim(); if (query !== "") { - var results = Fuzzysort.go(query, filtered, { + var results = FuzzySort.go(query, filtered, { "keys": ["name", "description"], "threshold": 0.35, "limit": 50 diff --git a/Modules/Panels/SetupWizard/SetupWallpaperStep.qml b/Modules/Panels/SetupWizard/SetupWallpaperStep.qml index 96a20fa65..213308807 100644 --- a/Modules/Panels/SetupWizard/SetupWallpaperStep.qml +++ b/Modules/Panels/SetupWizard/SetupWallpaperStep.qml @@ -3,7 +3,6 @@ import QtQuick.Controls import QtQuick.Layouts import Quickshell import Quickshell.Io -import "../../../Helpers/FuzzySort.js" as FuzzySort import qs.Commons import qs.Services.UI import qs.Widgets diff --git a/Modules/Panels/Wallpaper/WallpaperPanel.qml b/Modules/Panels/Wallpaper/WallpaperPanel.qml index 6f2b0bbd5..cdd10a467 100644 --- a/Modules/Panels/Wallpaper/WallpaperPanel.qml +++ b/Modules/Panels/Wallpaper/WallpaperPanel.qml @@ -2,7 +2,6 @@ import QtQuick import QtQuick.Controls import QtQuick.Layouts import Quickshell -import "../../../Helpers/FuzzySort.js" as FuzzySort import qs.Commons import qs.Modules.MainScreen import qs.Modules.Panels.Settings diff --git a/Widgets/NFilePicker.qml b/Widgets/NFilePicker.qml index 6b4af355b..e5be96308 100644 --- a/Widgets/NFilePicker.qml +++ b/Widgets/NFilePicker.qml @@ -4,7 +4,6 @@ import QtQuick.Controls import QtQuick.Layouts import Quickshell import Quickshell.Io -import "../Helpers/FuzzySort.js" as FuzzySort import qs.Commons import qs.Widgets diff --git a/Widgets/NSearchableComboBox.qml b/Widgets/NSearchableComboBox.qml index 8584926aa..dd1ff7c93 100644 --- a/Widgets/NSearchableComboBox.qml +++ b/Widgets/NSearchableComboBox.qml @@ -1,7 +1,6 @@ import QtQuick import QtQuick.Controls import QtQuick.Layouts -import "../Helpers/FuzzySort.js" as Fuzzysort import qs.Commons import qs.Widgets @@ -131,8 +130,8 @@ RowLayout { } // Use fuzzy search if available, fallback to simple search - if (typeof Fuzzysort !== 'undefined') { - var fuzzyResults = Fuzzysort.go(query, items, { + if (typeof FuzzySort !== 'undefined') { + var fuzzyResults = FuzzySort.go(query, items, { "key": "name", "threshold": -1000, "limit": 50