@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/services/search/common/replace.js

@@ -0,0 +1,203 @@
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { buildReplaceStringWithCasePreserved } from 'monaco-editor/esm/vs/base/common/search.js';
+class ReplacePattern {
+    constructor(replaceString, arg2, arg3) {
+        this._hasParameters = false;
+        this._replacePattern = replaceString;
+        let searchPatternInfo;
+        let parseParameters;
+        if (typeof arg2 === 'boolean') {
+            parseParameters = arg2;
+            this._regExp = arg3;
+        }
+        else {
+            searchPatternInfo = arg2;
+            parseParameters = !!searchPatternInfo.isRegExp;
+            this._regExp = strings.createRegExp(searchPatternInfo.pattern, !!searchPatternInfo.isRegExp, { matchCase: searchPatternInfo.isCaseSensitive, wholeWord: searchPatternInfo.isWordMatch, multiline: searchPatternInfo.isMultiline, global: false, unicode: true });
+        }
+        if (parseParameters) {
+            this.parseReplaceString(replaceString);
+        }
+        if (this._regExp.global) {
+            this._regExp = strings.createRegExp(this._regExp.source, true, { matchCase: !this._regExp.ignoreCase, wholeWord: false, multiline: this._regExp.multiline, global: false });
+        }
+        this._caseOpsRegExp = ( new RegExp(/([\s\S]*?)((?:\\[uUlL])+?|)(\$[0-9]+)([\s\S]*?)/g));
+    }
+    get hasParameters() {
+        return this._hasParameters;
+    }
+    get pattern() {
+        return this._replacePattern;
+    }
+    get regExp() {
+        return this._regExp;
+    }
+    getReplaceString(text, preserveCase) {
+        this._regExp.lastIndex = 0;
+        const match = this._regExp.exec(text);
+        if (match) {
+            if (this.hasParameters) {
+                const replaceString = this.replaceWithCaseOperations(text, this._regExp, this.buildReplaceString(match, preserveCase));
+                if (match[0] === text) {
+                    return replaceString;
+                }
+                return replaceString.substr(match.index, match[0].length - (text.length - replaceString.length));
+            }
+            return this.buildReplaceString(match, preserveCase);
+        }
+        return null;
+    }
+    replaceWithCaseOperations(text, regex, replaceString) {
+        if (!/\\[uUlL]/.test(replaceString)) {
+            return text.replace(regex, replaceString);
+        }
+        const firstMatch = regex.exec(text);
+        if (firstMatch === null) {
+            return text.replace(regex, replaceString);
+        }
+        let patMatch;
+        let newReplaceString = '';
+        let lastIndex = 0;
+        let lastMatch = '';
+        while ((patMatch = this._caseOpsRegExp.exec(replaceString)) !== null) {
+            lastIndex = patMatch.index;
+            const fullMatch = patMatch[0];
+            lastMatch = fullMatch;
+            let caseOps = patMatch[2];
+            const money = patMatch[3];
+            if (!caseOps) {
+                newReplaceString += fullMatch;
+                continue;
+            }
+            const replacement = firstMatch[parseInt(money.slice(1))];
+            if (!replacement) {
+                newReplaceString += fullMatch;
+                continue;
+            }
+            const replacementLen = replacement.length;
+            newReplaceString += patMatch[1];
+            caseOps = caseOps.replace(/\\/g, '');
+            let i = 0;
+            for (; i < caseOps.length; i++) {
+                switch (caseOps[i]) {
+                    case 'U':
+                        newReplaceString += replacement.slice(i).toUpperCase();
+                        i = replacementLen;
+                        break;
+                    case 'u':
+                        newReplaceString += replacement[i].toUpperCase();
+                        break;
+                    case 'L':
+                        newReplaceString += replacement.slice(i).toLowerCase();
+                        i = replacementLen;
+                        break;
+                    case 'l':
+                        newReplaceString += replacement[i].toLowerCase();
+                        break;
+                }
+            }
+            if (i < replacementLen) {
+                newReplaceString += replacement.slice(i);
+            }
+            newReplaceString += patMatch[4];
+        }
+        newReplaceString += replaceString.slice(lastIndex + lastMatch.length);
+        return text.replace(regex, newReplaceString);
+    }
+    buildReplaceString(matches, preserveCase) {
+        if (preserveCase) {
+            return buildReplaceStringWithCasePreserved(matches, this._replacePattern);
+        }
+        else {
+            return this._replacePattern;
+        }
+    }
+    parseReplaceString(replaceString) {
+        if (!replaceString || replaceString.length === 0) {
+            return;
+        }
+        let substrFrom = 0, result = '';
+        for (let i = 0, len = replaceString.length; i < len; i++) {
+            const chCode = replaceString.charCodeAt(i);
+            if (chCode === 92 ) {
+                i++;
+                if (i >= len) {
+                    break;
+                }
+                const nextChCode = replaceString.charCodeAt(i);
+                let replaceWithCharacter = null;
+                switch (nextChCode) {
+                    case 92 :
+                        replaceWithCharacter = '\\';
+                        break;
+                    case 110 :
+                        replaceWithCharacter = '\n';
+                        break;
+                    case 116 :
+                        replaceWithCharacter = '\t';
+                        break;
+                }
+                if (replaceWithCharacter) {
+                    result += replaceString.substring(substrFrom, i - 1) + replaceWithCharacter;
+                    substrFrom = i + 1;
+                }
+            }
+            if (chCode === 36 ) {
+                i++;
+                if (i >= len) {
+                    break;
+                }
+                const nextChCode = replaceString.charCodeAt(i);
+                let replaceWithCharacter = null;
+                switch (nextChCode) {
+                    case 48 :
+                        replaceWithCharacter = '$&';
+                        this._hasParameters = true;
+                        break;
+                    case 96 :
+                    case 39 :
+                        this._hasParameters = true;
+                        break;
+                    default: {
+                        if (!this.between(nextChCode, 49 , 57 )) {
+                            break;
+                        }
+                        if (i === replaceString.length - 1) {
+                            this._hasParameters = true;
+                            break;
+                        }
+                        let charCode = replaceString.charCodeAt(++i);
+                        if (!this.between(charCode, 48 , 57 )) {
+                            this._hasParameters = true;
+                            --i;
+                            break;
+                        }
+                        if (i === replaceString.length - 1) {
+                            this._hasParameters = true;
+                            break;
+                        }
+                        charCode = replaceString.charCodeAt(++i);
+                        if (!this.between(charCode, 48 , 57 )) {
+                            this._hasParameters = true;
+                            --i;
+                            break;
+                        }
+                        break;
+                    }
+                }
+                if (replaceWithCharacter) {
+                    result += replaceString.substring(substrFrom, i - 1) + replaceWithCharacter;
+                    substrFrom = i + 1;
+                }
+            }
+        }
+        if (substrFrom === 0) {
+            return;
+        }
+        this._replacePattern = result + replaceString.substring(substrFrom);
+    }
+    between(value, from, to) {
+        return from <= value && value <= to;
+    }
+}
+export { ReplacePattern };

package/dist/vscode/vs/workbench/services/search/common/search.js

@@ -1,13 +1,98 @@
+import { mapArrayOrNot } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as extpath from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { getNLines } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { isThenable } from 'monaco-editor/esm/vs/base/common/async.js';
+const VIEWLET_ID = 'workbench.view.search';
+const VIEW_ID = 'workbench.view.search';
 const SEARCH_EXCLUDE_CONFIG = 'search.exclude';
+const SEARCH_ELIDED_PREFIX = '⟪ ';
+const SEARCH_ELIDED_SUFFIX = ' characters skipped ⟫';
+const SEARCH_ELIDED_MIN_LEN = (SEARCH_ELIDED_PREFIX.length + SEARCH_ELIDED_SUFFIX.length + 5) * 2;
 const ISearchService = ( createDecorator('searchService'));
 function resultIsMatch(result) {
     return !!result.preview;
 }
+function isFileMatch(p) {
+    return !!p.resource;
+}
+function isProgressMessage(p) {
+    return !!p.message;
+}
+class FileMatch {
+    constructor(resource) {
+        this.resource = resource;
+        this.results = [];
+    }
+}
+class TextSearchMatch {
+    constructor(text, range, previewOptions, webviewIndex) {
+        this.ranges = range;
+        this.webviewIndex = webviewIndex;
+        const ranges = Array.isArray(range) ? range : [range];
+        if (previewOptions && previewOptions.matchLines === 1 && isSingleLineRangeList(ranges)) {
+            text = getNLines(text, previewOptions.matchLines);
+            let result = '';
+            let shift = 0;
+            let lastEnd = 0;
+            const leadingChars = Math.floor(previewOptions.charsPerLine / 5);
+            const matches = [];
+            for (const range of ranges) {
+                const previewStart = Math.max(range.startColumn - leadingChars, 0);
+                const previewEnd = range.startColumn + previewOptions.charsPerLine;
+                if (previewStart > lastEnd + leadingChars + SEARCH_ELIDED_MIN_LEN) {
+                    const elision = SEARCH_ELIDED_PREFIX + (previewStart - lastEnd) + SEARCH_ELIDED_SUFFIX;
+                    result += elision + text.slice(previewStart, previewEnd);
+                    shift += previewStart - (lastEnd + elision.length);
+                }
+                else {
+                    result += text.slice(lastEnd, previewEnd);
+                }
+                matches.push(( new OneLineRange(0, range.startColumn - shift, range.endColumn - shift)));
+                lastEnd = previewEnd;
+            }
+            this.preview = { text: result, matches: Array.isArray(this.ranges) ? matches : matches[0] };
+        }
+        else {
+            const firstMatchLine = Array.isArray(range) ? range[0].startLineNumber : range.startLineNumber;
+            this.preview = {
+                text,
+                matches: mapArrayOrNot(range, r => ( new SearchRange(
+                    r.startLineNumber - firstMatchLine,
+                    r.startColumn,
+                    r.endLineNumber - firstMatchLine,
+                    r.endColumn
+                )))
+            };
+        }
+    }
+}
+function isSingleLineRangeList(ranges) {
+    const line = ranges[0].startLineNumber;
+    for (const r of ranges) {
+        if (r.startLineNumber !== line || r.endLineNumber !== line) {
+            return false;
+        }
+    }
+    return true;
+}
+class SearchRange {
+    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {
+        this.startLineNumber = startLineNumber;
+        this.startColumn = startColumn;
+        this.endLineNumber = endLineNumber;
+        this.endColumn = endColumn;
+    }
+}
+class OneLineRange extends SearchRange {
+    constructor(lineNumber, startColumn, endColumn) {
+        super(lineNumber, startColumn, lineNumber, endColumn);
+    }
+}
 function getExcludes(configuration, includeSearchExcludes = true) {
     const fileExcludes = configuration && configuration.files && configuration.files.exclude;
     const searchExcludes = includeSearchExcludes && configuration && configuration.search && configuration.search.exclude;
@@ -46,4 +131,145 @@ function pathIncludedInQuery(queryProps, fsPath) {
     }
     return true;
 }
-export { ISearchService, SEARCH_EXCLUDE_CONFIG, getExcludes, pathIncludedInQuery, resultIsMatch };
+var SearchErrorCode;
+( (function(SearchErrorCode) {
+    SearchErrorCode[SearchErrorCode["unknownEncoding"] = 1] = "unknownEncoding";
+    SearchErrorCode[SearchErrorCode["regexParseError"] = 2] = "regexParseError";
+    SearchErrorCode[SearchErrorCode["globParseError"] = 3] = "globParseError";
+    SearchErrorCode[SearchErrorCode["invalidLiteral"] = 4] = "invalidLiteral";
+    SearchErrorCode[SearchErrorCode["rgProcessError"] = 5] = "rgProcessError";
+    SearchErrorCode[SearchErrorCode["other"] = 6] = "other";
+    SearchErrorCode[SearchErrorCode["canceled"] = 7] = "canceled";
+})(SearchErrorCode || (SearchErrorCode = {})));
+class SearchError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+function deserializeSearchError(error) {
+    const errorMsg = error.message;
+    if (isCancellationError(error)) {
+        return ( new SearchError(errorMsg, SearchErrorCode.canceled));
+    }
+    try {
+        const details = JSON.parse(errorMsg);
+        return ( new SearchError(details.message, details.code));
+    }
+    catch (e) {
+        return ( new SearchError(errorMsg, SearchErrorCode.other));
+    }
+}
+function resolvePatternsForProvider(globalPattern, folderPattern) {
+    const merged = {
+        ...(globalPattern || {}),
+        ...(folderPattern || {})
+    };
+    return ( Object.keys(merged))
+        .filter(key => {
+        const value = merged[key];
+        return typeof value === 'boolean' && value;
+    });
+}
+class QueryGlobTester {
+    constructor(config, folderQuery) {
+        this._parsedIncludeExpression = null;
+        this._excludeExpression = {
+            ...(config.excludePattern || {}),
+            ...(folderQuery.excludePattern || {})
+        };
+        this._parsedExcludeExpression = glob.parse(this._excludeExpression);
+        let includeExpression = config.includePattern;
+        if (folderQuery.includePattern) {
+            if (includeExpression) {
+                includeExpression = {
+                    ...includeExpression,
+                    ...folderQuery.includePattern
+                };
+            }
+            else {
+                includeExpression = folderQuery.includePattern;
+            }
+        }
+        if (includeExpression) {
+            this._parsedIncludeExpression = glob.parse(includeExpression);
+        }
+    }
+    matchesExcludesSync(testPath, basename, hasSibling) {
+        if (this._parsedExcludeExpression && this._parsedExcludeExpression(testPath, basename, hasSibling)) {
+            return true;
+        }
+        return false;
+    }
+    includedInQuerySync(testPath, basename, hasSibling) {
+        if (this._parsedExcludeExpression && this._parsedExcludeExpression(testPath, basename, hasSibling)) {
+            return false;
+        }
+        if (this._parsedIncludeExpression && !this._parsedIncludeExpression(testPath, basename, hasSibling)) {
+            return false;
+        }
+        return true;
+    }
+    includedInQuery(testPath, basename, hasSibling) {
+        const excluded = this._parsedExcludeExpression(testPath, basename, hasSibling);
+        const isIncluded = () => {
+            return this._parsedIncludeExpression ?
+                !!(this._parsedIncludeExpression(testPath, basename, hasSibling)) :
+                true;
+        };
+        if (isThenable(excluded)) {
+            return excluded.then(excluded => {
+                if (excluded) {
+                    return false;
+                }
+                return isIncluded();
+            });
+        }
+        return isIncluded();
+    }
+    hasSiblingExcludeClauses() {
+        return hasSiblingClauses(this._excludeExpression);
+    }
+}
+function hasSiblingClauses(pattern) {
+    for (const key in pattern) {
+        if (typeof pattern[key] !== 'boolean') {
+            return true;
+        }
+    }
+    return false;
+}
+function hasSiblingPromiseFn(siblingsFn) {
+    if (!siblingsFn) {
+        return undefined;
+    }
+    let siblings;
+    return (name) => {
+        if (!siblings) {
+            siblings = (siblingsFn() || Promise.resolve([]))
+                .then(list => list ? listToMap(list) : {});
+        }
+        return siblings.then(map => !!map[name]);
+    };
+}
+function hasSiblingFn(siblingsFn) {
+    if (!siblingsFn) {
+        return undefined;
+    }
+    let siblings;
+    return (name) => {
+        if (!siblings) {
+            const list = siblingsFn();
+            siblings = list ? listToMap(list) : {};
+        }
+        return !!siblings[name];
+    };
+}
+function listToMap(list) {
+    const map = {};
+    for (const key of list) {
+        map[key] = true;
+    }
+    return map;
+}
+export { FileMatch, ISearchService, OneLineRange, QueryGlobTester, SEARCH_EXCLUDE_CONFIG, SearchError, SearchErrorCode, SearchRange, TextSearchMatch, VIEWLET_ID, VIEW_ID, deserializeSearchError, getExcludes, hasSiblingFn, hasSiblingPromiseFn, isFileMatch, isProgressMessage, pathIncludedInQuery, resolvePatternsForProvider, resultIsMatch };

package/dist/vscode/vs/workbench/services/search/common/searchExtTypes.js

@@ -0,0 +1,6 @@
+var TextSearchCompleteMessageType;
+( (function(TextSearchCompleteMessageType) {
+    TextSearchCompleteMessageType[TextSearchCompleteMessageType["Information"] = 1] = "Information";
+    TextSearchCompleteMessageType[TextSearchCompleteMessageType["Warning"] = 2] = "Warning";
+})(TextSearchCompleteMessageType || (TextSearchCompleteMessageType = {})));
+export { TextSearchCompleteMessageType };

package/dist/vscode/vs/workbench/services/search/common/searchHelpers.js

@@ -0,0 +1,72 @@
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { TextSearchMatch } from './search.js';
+function editorMatchToTextSearchResult(matches, model, previewOptions) {
+    const firstLine = matches[0].range.startLineNumber;
+    const lastLine = matches[matches.length - 1].range.endLineNumber;
+    const lineTexts = [];
+    for (let i = firstLine; i <= lastLine; i++) {
+        lineTexts.push(model.getLineContent(i));
+    }
+    return ( new TextSearchMatch(lineTexts.join('\n') + '\n', ( matches.map(m => ( new Range(
+        m.range.startLineNumber - 1,
+        m.range.startColumn - 1,
+        m.range.endLineNumber - 1,
+        m.range.endColumn - 1
+    )))), previewOptions));
+}
+function editorMatchesToTextSearchResults(matches, model, previewOptions) {
+    let previousEndLine = -1;
+    const groupedMatches = [];
+    let currentMatches = [];
+    matches.forEach((match) => {
+        if (match.range.startLineNumber !== previousEndLine) {
+            currentMatches = [];
+            groupedMatches.push(currentMatches);
+        }
+        currentMatches.push(match);
+        previousEndLine = match.range.endLineNumber;
+    });
+    return ( groupedMatches.map(sameLineMatches => {
+        return editorMatchToTextSearchResult(sameLineMatches, model, previewOptions);
+    }));
+}
+function addContextToEditorMatches(matches, model, query) {
+    const results = [];
+    let prevLine = -1;
+    for (let i = 0; i < matches.length; i++) {
+        const { start: matchStartLine, end: matchEndLine } = getMatchStartEnd(matches[i]);
+        if (typeof query.beforeContext === 'number' && query.beforeContext > 0) {
+            const beforeContextStartLine = Math.max(prevLine + 1, matchStartLine - query.beforeContext);
+            for (let b = beforeContextStartLine; b < matchStartLine; b++) {
+                results.push({
+                    text: model.getLineContent(b + 1),
+                    lineNumber: b
+                });
+            }
+        }
+        results.push(matches[i]);
+        const nextMatch = matches[i + 1];
+        const nextMatchStartLine = nextMatch ? getMatchStartEnd(nextMatch).start : Number.MAX_VALUE;
+        if (typeof query.afterContext === 'number' && query.afterContext > 0) {
+            const afterContextToLine = Math.min(nextMatchStartLine - 1, matchEndLine + query.afterContext, model.getLineCount() - 1);
+            for (let a = matchEndLine + 1; a <= afterContextToLine; a++) {
+                results.push({
+                    text: model.getLineContent(a + 1),
+                    lineNumber: a
+                });
+            }
+        }
+        prevLine = matchEndLine;
+    }
+    return results;
+}
+function getMatchStartEnd(match) {
+    const matchRanges = match.ranges;
+    const matchStartLine = Array.isArray(matchRanges) ? matchRanges[0].startLineNumber : matchRanges.startLineNumber;
+    const matchEndLine = Array.isArray(matchRanges) ? matchRanges[matchRanges.length - 1].endLineNumber : matchRanges.endLineNumber;
+    return {
+        start: matchStartLine,
+        end: matchEndLine
+    };
+}
+export { addContextToEditorMatches, editorMatchesToTextSearchResults };