@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/base/common/fuzzyScorer.js

@@ -0,0 +1,483 @@
+import { compareAnything } from './comparers.js';
+import { fuzzyScore, createMatches as createMatches$1, matchesPrefix, isUpper } from './filters.js';
+import { hash } from './hash.js';
+import { sep } from './path.js';
+import { isLinux, isWindows } from './platform.js';
+import { equalsIgnoreCase, stripWildcards } from './strings.js';
+const NO_MATCH = 0;
+const NO_SCORE = [NO_MATCH, []];
+function scoreFuzzy(target, query, queryLower, allowNonContiguousMatches) {
+    if (!target || !query) {
+        return NO_SCORE;
+    }
+    const targetLength = target.length;
+    const queryLength = query.length;
+    if (targetLength < queryLength) {
+        return NO_SCORE;
+    }
+    const targetLower = target.toLowerCase();
+    const res = doScoreFuzzy(query, queryLower, queryLength, target, targetLower, targetLength, allowNonContiguousMatches);
+    return res;
+}
+function doScoreFuzzy(query, queryLower, queryLength, target, targetLower, targetLength, allowNonContiguousMatches) {
+    const scores = [];
+    const matches = [];
+    for (let queryIndex = 0; queryIndex < queryLength; queryIndex++) {
+        const queryIndexOffset = queryIndex * targetLength;
+        const queryIndexPreviousOffset = queryIndexOffset - targetLength;
+        const queryIndexGtNull = queryIndex > 0;
+        const queryCharAtIndex = query[queryIndex];
+        const queryLowerCharAtIndex = queryLower[queryIndex];
+        for (let targetIndex = 0; targetIndex < targetLength; targetIndex++) {
+            const targetIndexGtNull = targetIndex > 0;
+            const currentIndex = queryIndexOffset + targetIndex;
+            const leftIndex = currentIndex - 1;
+            const diagIndex = queryIndexPreviousOffset + targetIndex - 1;
+            const leftScore = targetIndexGtNull ? scores[leftIndex] : 0;
+            const diagScore = queryIndexGtNull && targetIndexGtNull ? scores[diagIndex] : 0;
+            const matchesSequenceLength = queryIndexGtNull && targetIndexGtNull ? matches[diagIndex] : 0;
+            let score;
+            if (!diagScore && queryIndexGtNull) {
+                score = 0;
+            }
+            else {
+                score = computeCharScore(queryCharAtIndex, queryLowerCharAtIndex, target, targetLower, targetIndex, matchesSequenceLength);
+            }
+            const isValidScore = score && diagScore + score >= leftScore;
+            if (isValidScore && (
+            (allowNonContiguousMatches ||
+                queryIndexGtNull ||
+            targetLower.startsWith(queryLower, targetIndex)))) {
+                matches[currentIndex] = matchesSequenceLength + 1;
+                scores[currentIndex] = diagScore + score;
+            }
+            else {
+                matches[currentIndex] = NO_MATCH;
+                scores[currentIndex] = leftScore;
+            }
+        }
+    }
+    const positions = [];
+    let queryIndex = queryLength - 1;
+    let targetIndex = targetLength - 1;
+    while (queryIndex >= 0 && targetIndex >= 0) {
+        const currentIndex = queryIndex * targetLength + targetIndex;
+        const match = matches[currentIndex];
+        if (match === NO_MATCH) {
+            targetIndex--;
+        }
+        else {
+            positions.push(targetIndex);
+            queryIndex--;
+            targetIndex--;
+        }
+    }
+    return [scores[queryLength * targetLength - 1], positions.reverse()];
+}
+function computeCharScore(queryCharAtIndex, queryLowerCharAtIndex, target, targetLower, targetIndex, matchesSequenceLength) {
+    let score = 0;
+    if (!considerAsEqual(queryLowerCharAtIndex, targetLower[targetIndex])) {
+        return score;
+    }
+    score += 1;
+    if (matchesSequenceLength > 0) {
+        score += (matchesSequenceLength * 5);
+    }
+    if (queryCharAtIndex === target[targetIndex]) {
+        score += 1;
+    }
+    if (targetIndex === 0) {
+        score += 8;
+    }
+    else {
+        const separatorBonus = scoreSeparatorAtPos(target.charCodeAt(targetIndex - 1));
+        if (separatorBonus) {
+            score += separatorBonus;
+        }
+        else if (isUpper(target.charCodeAt(targetIndex)) && matchesSequenceLength === 0) {
+            score += 2;
+        }
+    }
+    return score;
+}
+function considerAsEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a === '/' || a === '\\') {
+        return b === '/' || b === '\\';
+    }
+    return false;
+}
+function scoreSeparatorAtPos(charCode) {
+    switch (charCode) {
+        case 47 :
+        case 92 :
+            return 5;
+        case 95 :
+        case 45 :
+        case 46 :
+        case 32 :
+        case 39 :
+        case 34 :
+        case 58 :
+            return 4;
+        default:
+            return 0;
+    }
+}
+const NO_SCORE2 = [undefined, []];
+function scoreFuzzy2(target, query, patternStart = 0, wordStart = 0) {
+    const preparedQuery = query;
+    if (preparedQuery.values && preparedQuery.values.length > 1) {
+        return doScoreFuzzy2Multiple(target, preparedQuery.values, patternStart, wordStart);
+    }
+    return doScoreFuzzy2Single(target, query, patternStart, wordStart);
+}
+function doScoreFuzzy2Multiple(target, query, patternStart, wordStart) {
+    let totalScore = 0;
+    const totalMatches = [];
+    for (const queryPiece of query) {
+        const [score, matches] = doScoreFuzzy2Single(target, queryPiece, patternStart, wordStart);
+        if (typeof score !== 'number') {
+            return NO_SCORE2;
+        }
+        totalScore += score;
+        totalMatches.push(...matches);
+    }
+    return [totalScore, normalizeMatches(totalMatches)];
+}
+function doScoreFuzzy2Single(target, query, patternStart, wordStart) {
+    const score = fuzzyScore(query.original, query.originalLowercase, patternStart, target, target.toLowerCase(), wordStart, { firstMatchCanBeWeak: true, boostFullMatch: true });
+    if (!score) {
+        return NO_SCORE2;
+    }
+    return [score[0], createMatches$1(score)];
+}
+const NO_ITEM_SCORE = ( Object.freeze({ score: 0 }));
+const PATH_IDENTITY_SCORE = 1 << 18;
+const LABEL_PREFIX_SCORE_THRESHOLD = 1 << 17;
+const LABEL_SCORE_THRESHOLD = 1 << 16;
+function getCacheHash(label, description, allowNonContiguousMatches, query) {
+    const values = query.values ? query.values : [query];
+    const cacheHash = hash({
+        [query.normalized]: {
+            values: ( values.map(
+                v => ({ value: v.normalized, expectContiguousMatch: v.expectContiguousMatch })
+            )),
+            label,
+            description,
+            allowNonContiguousMatches
+        }
+    });
+    return cacheHash;
+}
+function scoreItemFuzzy(item, query, allowNonContiguousMatches, accessor, cache) {
+    if (!item || !query.normalized) {
+        return NO_ITEM_SCORE;
+    }
+    const label = accessor.getItemLabel(item);
+    if (!label) {
+        return NO_ITEM_SCORE;
+    }
+    const description = accessor.getItemDescription(item);
+    const cacheHash = getCacheHash(label, description, allowNonContiguousMatches, query);
+    const cached = cache[cacheHash];
+    if (cached) {
+        return cached;
+    }
+    const itemScore = doScoreItemFuzzy(label, description, accessor.getItemPath(item), query, allowNonContiguousMatches);
+    cache[cacheHash] = itemScore;
+    return itemScore;
+}
+function doScoreItemFuzzy(label, description, path, query, allowNonContiguousMatches) {
+    const preferLabelMatches = !path || !query.containsPathSeparator;
+    if (path && (isLinux ? query.pathNormalized === path : equalsIgnoreCase(query.pathNormalized, path))) {
+        return { score: PATH_IDENTITY_SCORE, labelMatch: [{ start: 0, end: label.length }], descriptionMatch: description ? [{ start: 0, end: description.length }] : undefined };
+    }
+    if (query.values && query.values.length > 1) {
+        return doScoreItemFuzzyMultiple(label, description, path, query.values, preferLabelMatches, allowNonContiguousMatches);
+    }
+    return doScoreItemFuzzySingle(label, description, path, query, preferLabelMatches, allowNonContiguousMatches);
+}
+function doScoreItemFuzzyMultiple(label, description, path, query, preferLabelMatches, allowNonContiguousMatches) {
+    let totalScore = 0;
+    const totalLabelMatches = [];
+    const totalDescriptionMatches = [];
+    for (const queryPiece of query) {
+        const { score, labelMatch, descriptionMatch } = doScoreItemFuzzySingle(label, description, path, queryPiece, preferLabelMatches, allowNonContiguousMatches);
+        if (score === NO_MATCH) {
+            return NO_ITEM_SCORE;
+        }
+        totalScore += score;
+        if (labelMatch) {
+            totalLabelMatches.push(...labelMatch);
+        }
+        if (descriptionMatch) {
+            totalDescriptionMatches.push(...descriptionMatch);
+        }
+    }
+    return {
+        score: totalScore,
+        labelMatch: normalizeMatches(totalLabelMatches),
+        descriptionMatch: normalizeMatches(totalDescriptionMatches)
+    };
+}
+function doScoreItemFuzzySingle(label, description, path, query, preferLabelMatches, allowNonContiguousMatches) {
+    if (preferLabelMatches || !description) {
+        const [labelScore, labelPositions] = scoreFuzzy(label, query.normalized, query.normalizedLowercase, allowNonContiguousMatches && !query.expectContiguousMatch);
+        if (labelScore) {
+            const labelPrefixMatch = matchesPrefix(query.normalized, label);
+            let baseScore;
+            if (labelPrefixMatch) {
+                baseScore = LABEL_PREFIX_SCORE_THRESHOLD;
+                const prefixLengthBoost = Math.round((query.normalized.length / label.length) * 100);
+                baseScore += prefixLengthBoost;
+            }
+            else {
+                baseScore = LABEL_SCORE_THRESHOLD;
+            }
+            return { score: baseScore + labelScore, labelMatch: labelPrefixMatch || createMatches(labelPositions) };
+        }
+    }
+    if (description) {
+        let descriptionPrefix = description;
+        if (!!path) {
+            descriptionPrefix = `${description}${sep}`;
+        }
+        const descriptionPrefixLength = descriptionPrefix.length;
+        const descriptionAndLabel = `${descriptionPrefix}${label}`;
+        const [labelDescriptionScore, labelDescriptionPositions] = scoreFuzzy(descriptionAndLabel, query.normalized, query.normalizedLowercase, allowNonContiguousMatches && !query.expectContiguousMatch);
+        if (labelDescriptionScore) {
+            const labelDescriptionMatches = createMatches(labelDescriptionPositions);
+            const labelMatch = [];
+            const descriptionMatch = [];
+            labelDescriptionMatches.forEach(h => {
+                if (h.start < descriptionPrefixLength && h.end > descriptionPrefixLength) {
+                    labelMatch.push({ start: 0, end: h.end - descriptionPrefixLength });
+                    descriptionMatch.push({ start: h.start, end: descriptionPrefixLength });
+                }
+                else if (h.start >= descriptionPrefixLength) {
+                    labelMatch.push({ start: h.start - descriptionPrefixLength, end: h.end - descriptionPrefixLength });
+                }
+                else {
+                    descriptionMatch.push(h);
+                }
+            });
+            return { score: labelDescriptionScore, labelMatch, descriptionMatch };
+        }
+    }
+    return NO_ITEM_SCORE;
+}
+function createMatches(offsets) {
+    const ret = [];
+    if (!offsets) {
+        return ret;
+    }
+    let last;
+    for (const pos of offsets) {
+        if (last && last.end === pos) {
+            last.end += 1;
+        }
+        else {
+            last = { start: pos, end: pos + 1 };
+            ret.push(last);
+        }
+    }
+    return ret;
+}
+function normalizeMatches(matches) {
+    const sortedMatches = matches.sort((matchA, matchB) => {
+        return matchA.start - matchB.start;
+    });
+    const normalizedMatches = [];
+    let currentMatch = undefined;
+    for (const match of sortedMatches) {
+        if (!currentMatch || !matchOverlaps(currentMatch, match)) {
+            currentMatch = match;
+            normalizedMatches.push(match);
+        }
+        else {
+            currentMatch.start = Math.min(currentMatch.start, match.start);
+            currentMatch.end = Math.max(currentMatch.end, match.end);
+        }
+    }
+    return normalizedMatches;
+}
+function matchOverlaps(matchA, matchB) {
+    if (matchA.end < matchB.start) {
+        return false;
+    }
+    if (matchB.end < matchA.start) {
+        return false;
+    }
+    return true;
+}
+function compareItemsByFuzzyScore(itemA, itemB, query, allowNonContiguousMatches, accessor, cache) {
+    const itemScoreA = scoreItemFuzzy(itemA, query, allowNonContiguousMatches, accessor, cache);
+    const itemScoreB = scoreItemFuzzy(itemB, query, allowNonContiguousMatches, accessor, cache);
+    const scoreA = itemScoreA.score;
+    const scoreB = itemScoreB.score;
+    if (scoreA === PATH_IDENTITY_SCORE || scoreB === PATH_IDENTITY_SCORE) {
+        if (scoreA !== scoreB) {
+            return scoreA === PATH_IDENTITY_SCORE ? -1 : 1;
+        }
+    }
+    if (scoreA > LABEL_SCORE_THRESHOLD || scoreB > LABEL_SCORE_THRESHOLD) {
+        if (scoreA !== scoreB) {
+            return scoreA > scoreB ? -1 : 1;
+        }
+        if (scoreA < LABEL_PREFIX_SCORE_THRESHOLD && scoreB < LABEL_PREFIX_SCORE_THRESHOLD) {
+            const comparedByMatchLength = compareByMatchLength(itemScoreA.labelMatch, itemScoreB.labelMatch);
+            if (comparedByMatchLength !== 0) {
+                return comparedByMatchLength;
+            }
+        }
+        const labelA = accessor.getItemLabel(itemA) || '';
+        const labelB = accessor.getItemLabel(itemB) || '';
+        if (labelA.length !== labelB.length) {
+            return labelA.length - labelB.length;
+        }
+    }
+    if (scoreA !== scoreB) {
+        return scoreA > scoreB ? -1 : 1;
+    }
+    const itemAHasLabelMatches = Array.isArray(itemScoreA.labelMatch) && itemScoreA.labelMatch.length > 0;
+    const itemBHasLabelMatches = Array.isArray(itemScoreB.labelMatch) && itemScoreB.labelMatch.length > 0;
+    if (itemAHasLabelMatches && !itemBHasLabelMatches) {
+        return -1;
+    }
+    else if (itemBHasLabelMatches && !itemAHasLabelMatches) {
+        return 1;
+    }
+    const itemAMatchDistance = computeLabelAndDescriptionMatchDistance(itemA, itemScoreA, accessor);
+    const itemBMatchDistance = computeLabelAndDescriptionMatchDistance(itemB, itemScoreB, accessor);
+    if (itemAMatchDistance && itemBMatchDistance && itemAMatchDistance !== itemBMatchDistance) {
+        return itemBMatchDistance > itemAMatchDistance ? -1 : 1;
+    }
+    return fallbackCompare(itemA, itemB, query, accessor);
+}
+function computeLabelAndDescriptionMatchDistance(item, score, accessor) {
+    let matchStart = -1;
+    let matchEnd = -1;
+    if (score.descriptionMatch && score.descriptionMatch.length) {
+        matchStart = score.descriptionMatch[0].start;
+    }
+    else if (score.labelMatch && score.labelMatch.length) {
+        matchStart = score.labelMatch[0].start;
+    }
+    if (score.labelMatch && score.labelMatch.length) {
+        matchEnd = score.labelMatch[score.labelMatch.length - 1].end;
+        if (score.descriptionMatch && score.descriptionMatch.length) {
+            const itemDescription = accessor.getItemDescription(item);
+            if (itemDescription) {
+                matchEnd += itemDescription.length;
+            }
+        }
+    }
+    else if (score.descriptionMatch && score.descriptionMatch.length) {
+        matchEnd = score.descriptionMatch[score.descriptionMatch.length - 1].end;
+    }
+    return matchEnd - matchStart;
+}
+function compareByMatchLength(matchesA, matchesB) {
+    if ((!matchesA && !matchesB) || ((!matchesA || !matchesA.length) && (!matchesB || !matchesB.length))) {
+        return 0;
+    }
+    if (!matchesB || !matchesB.length) {
+        return -1;
+    }
+    if (!matchesA || !matchesA.length) {
+        return 1;
+    }
+    const matchStartA = matchesA[0].start;
+    const matchEndA = matchesA[matchesA.length - 1].end;
+    const matchLengthA = matchEndA - matchStartA;
+    const matchStartB = matchesB[0].start;
+    const matchEndB = matchesB[matchesB.length - 1].end;
+    const matchLengthB = matchEndB - matchStartB;
+    return matchLengthA === matchLengthB ? 0 : matchLengthB < matchLengthA ? 1 : -1;
+}
+function fallbackCompare(itemA, itemB, query, accessor) {
+    const labelA = accessor.getItemLabel(itemA) || '';
+    const labelB = accessor.getItemLabel(itemB) || '';
+    const descriptionA = accessor.getItemDescription(itemA);
+    const descriptionB = accessor.getItemDescription(itemB);
+    const labelDescriptionALength = labelA.length + (descriptionA ? descriptionA.length : 0);
+    const labelDescriptionBLength = labelB.length + (descriptionB ? descriptionB.length : 0);
+    if (labelDescriptionALength !== labelDescriptionBLength) {
+        return labelDescriptionALength - labelDescriptionBLength;
+    }
+    const pathA = accessor.getItemPath(itemA);
+    const pathB = accessor.getItemPath(itemB);
+    if (pathA && pathB && pathA.length !== pathB.length) {
+        return pathA.length - pathB.length;
+    }
+    if (labelA !== labelB) {
+        return compareAnything(labelA, labelB, query.normalized);
+    }
+    if (descriptionA && descriptionB && descriptionA !== descriptionB) {
+        return compareAnything(descriptionA, descriptionB, query.normalized);
+    }
+    if (pathA && pathB && pathA !== pathB) {
+        return compareAnything(pathA, pathB, query.normalized);
+    }
+    return 0;
+}
+function queryExpectsExactMatch(query) {
+    return query.startsWith('"') && query.endsWith('"');
+}
+const MULTIPLE_QUERY_VALUES_SEPARATOR = ' ';
+function prepareQuery(original) {
+    if (typeof original !== 'string') {
+        original = '';
+    }
+    const originalLowercase = original.toLowerCase();
+    const { pathNormalized, normalized, normalizedLowercase } = normalizeQuery(original);
+    const containsPathSeparator = pathNormalized.indexOf(sep) >= 0;
+    const expectExactMatch = queryExpectsExactMatch(original);
+    let values = undefined;
+    const originalSplit = original.split(MULTIPLE_QUERY_VALUES_SEPARATOR);
+    if (originalSplit.length > 1) {
+        for (const originalPiece of originalSplit) {
+            const expectExactMatchPiece = queryExpectsExactMatch(originalPiece);
+            const { pathNormalized: pathNormalizedPiece, normalized: normalizedPiece, normalizedLowercase: normalizedLowercasePiece } = normalizeQuery(originalPiece);
+            if (normalizedPiece) {
+                if (!values) {
+                    values = [];
+                }
+                values.push({
+                    original: originalPiece,
+                    originalLowercase: originalPiece.toLowerCase(),
+                    pathNormalized: pathNormalizedPiece,
+                    normalized: normalizedPiece,
+                    normalizedLowercase: normalizedLowercasePiece,
+                    expectContiguousMatch: expectExactMatchPiece
+                });
+            }
+        }
+    }
+    return { original, originalLowercase, pathNormalized, normalized, normalizedLowercase, values, containsPathSeparator, expectContiguousMatch: expectExactMatch };
+}
+function normalizeQuery(original) {
+    let pathNormalized;
+    if (isWindows) {
+        pathNormalized = original.replace(/\//g, sep);
+    }
+    else {
+        pathNormalized = original.replace(/\\/g, sep);
+    }
+    const normalized = stripWildcards(pathNormalized).replace(/\s|"/g, '');
+    return {
+        pathNormalized,
+        normalized,
+        normalizedLowercase: normalized.toLowerCase()
+    };
+}
+function pieceToQuery(arg1) {
+    if (Array.isArray(arg1)) {
+        return prepareQuery(( arg1.map(piece => piece.original)).join(MULTIPLE_QUERY_VALUES_SEPARATOR));
+    }
+    return prepareQuery(arg1.original);
+}
+export { compareItemsByFuzzyScore, pieceToQuery, prepareQuery, scoreFuzzy, scoreFuzzy2, scoreItemFuzzy };