@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

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

@@ -6,6 +6,10 @@ 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;
@@ -156,4 +160,116 @@ function deserializeSearchError(error) {
         return ( new SearchError(errorMsg, SearchErrorCode.other));
     }
 }
-export { FileMatch, ISearchService, OneLineRange, SearchError, SearchErrorCode, SearchRange, TextSearchMatch, deserializeSearchError, getExcludes, isFileMatch, isProgressMessage, pathIncludedInQuery, resultIsMatch };
+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/textSearchManager.js

@@ -0,0 +1,309 @@
+import { flatten, mapArrayOrNot } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { isThenable } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { resolvePatternsForProvider, QueryGlobTester, hasSiblingPromiseFn } from './search.js';
+class TextSearchManager {
+    constructor(query, provider, fileUtils, processType) {
+        this.query = query;
+        this.provider = provider;
+        this.fileUtils = fileUtils;
+        this.processType = processType;
+        this.collector = null;
+        this.isLimitHit = false;
+        this.resultCount = 0;
+    }
+    search(onProgress, token) {
+        const folderQueries = this.query.folderQueries || [];
+        const tokenSource = ( new CancellationTokenSource());
+        token.onCancellationRequested(() => tokenSource.cancel());
+        return ( new Promise((resolve, reject) => {
+            this.collector = ( new TextSearchResultsCollector(onProgress));
+            let isCanceled = false;
+            const onResult = (result, folderIdx) => {
+                if (isCanceled) {
+                    return;
+                }
+                if (!this.isLimitHit) {
+                    const resultSize = this.resultSize(result);
+                    if (extensionResultIsMatch(result) && typeof this.query.maxResults === 'number' && this.resultCount + resultSize > this.query.maxResults) {
+                        this.isLimitHit = true;
+                        isCanceled = true;
+                        tokenSource.cancel();
+                        result = this.trimResultToSize(result, this.query.maxResults - this.resultCount);
+                    }
+                    const newResultSize = this.resultSize(result);
+                    this.resultCount += newResultSize;
+                    if (newResultSize > 0 || !extensionResultIsMatch(result)) {
+                        this.collector.add(result, folderIdx);
+                    }
+                }
+            };
+            Promise.all(( folderQueries.map((fq, i) => {
+                return this.searchInFolder(fq, r => onResult(r, i), tokenSource.token);
+            }))).then(results => {
+                tokenSource.dispose();
+                this.collector.flush();
+                const someFolderHitLImit = ( results.some(result => !!result && !!result.limitHit));
+                resolve({
+                    limitHit: this.isLimitHit || someFolderHitLImit,
+                    messages: flatten(( results.map(result => {
+                        if (!result?.message) {
+                            return [];
+                        }
+                        if (Array.isArray(result.message)) {
+                            return result.message;
+                        }
+                        else {
+                            return [result.message];
+                        }
+                    }))),
+                    stats: {
+                        type: this.processType
+                    }
+                });
+            }, (err) => {
+                tokenSource.dispose();
+                const errMsg = toErrorMessage(err);
+                reject(( new Error(errMsg)));
+            });
+        }));
+    }
+    resultSize(result) {
+        if (extensionResultIsMatch(result)) {
+            return Array.isArray(result.ranges) ?
+                result.ranges.length :
+                1;
+        }
+        else {
+            return 0;
+        }
+    }
+    trimResultToSize(result, size) {
+        const rangesArr = Array.isArray(result.ranges) ? result.ranges : [result.ranges];
+        const matchesArr = Array.isArray(result.preview.matches) ? result.preview.matches : [result.preview.matches];
+        return {
+            ranges: rangesArr.slice(0, size),
+            preview: {
+                matches: matchesArr.slice(0, size),
+                text: result.preview.text
+            },
+            uri: result.uri
+        };
+    }
+    async searchInFolder(folderQuery, onResult, token) {
+        const queryTester = ( new QueryGlobTester(this.query, folderQuery));
+        const testingPs = [];
+        const progress = {
+            report: (result) => {
+                if (!this.validateProviderResult(result)) {
+                    return;
+                }
+                const hasSibling = folderQuery.folder.scheme === Schemas.file ?
+                    hasSiblingPromiseFn(() => {
+                        return this.fileUtils.readdir(resources.dirname(result.uri));
+                    }) :
+                    undefined;
+                const relativePath = resources.relativePath(folderQuery.folder, result.uri);
+                if (relativePath) {
+                    const included = queryTester.includedInQuery(relativePath, path.basename(relativePath), hasSibling);
+                    if (isThenable(included)) {
+                        testingPs.push(included.then(isIncluded => {
+                            if (isIncluded) {
+                                onResult(result);
+                            }
+                        }));
+                    }
+                    else if (included) {
+                        onResult(result);
+                    }
+                }
+            }
+        };
+        const searchOptions = this.getSearchOptionsForFolder(folderQuery);
+        const result = await this.provider.provideTextSearchResults(patternInfoToQuery(this.query.contentPattern), searchOptions, progress, token);
+        if (testingPs.length) {
+            await Promise.all(testingPs);
+        }
+        return result;
+    }
+    validateProviderResult(result) {
+        if (extensionResultIsMatch(result)) {
+            if (Array.isArray(result.ranges)) {
+                if (!Array.isArray(result.preview.matches)) {
+                    console.warn('INVALID - A text search provider match\'s`ranges` and`matches` properties must have the same type.');
+                    return false;
+                }
+                if (result.preview.matches.length !== result.ranges.length) {
+                    console.warn('INVALID - A text search provider match\'s`ranges` and`matches` properties must have the same length.');
+                    return false;
+                }
+            }
+            else {
+                if (Array.isArray(result.preview.matches)) {
+                    console.warn('INVALID - A text search provider match\'s`ranges` and`matches` properties must have the same length.');
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    getSearchOptionsForFolder(fq) {
+        const includes = resolvePatternsForProvider(this.query.includePattern, fq.includePattern);
+        const excludes = resolvePatternsForProvider(this.query.excludePattern, fq.excludePattern);
+        const options = {
+            folder: ( URI.from(fq.folder)),
+            excludes,
+            includes,
+            useIgnoreFiles: !fq.disregardIgnoreFiles,
+            useGlobalIgnoreFiles: !fq.disregardGlobalIgnoreFiles,
+            useParentIgnoreFiles: !fq.disregardParentIgnoreFiles,
+            followSymlinks: !fq.ignoreSymlinks,
+            encoding: fq.fileEncoding && this.fileUtils.toCanonicalName(fq.fileEncoding),
+            maxFileSize: this.query.maxFileSize,
+            maxResults: this.query.maxResults,
+            previewOptions: this.query.previewOptions,
+            afterContext: this.query.afterContext,
+            beforeContext: this.query.beforeContext
+        };
+        options.usePCRE2 = this.query.usePCRE2;
+        return options;
+    }
+}
+function patternInfoToQuery(patternInfo) {
+    return {
+        isCaseSensitive: patternInfo.isCaseSensitive || false,
+        isRegExp: patternInfo.isRegExp || false,
+        isWordMatch: patternInfo.isWordMatch || false,
+        isMultiline: patternInfo.isMultiline || false,
+        pattern: patternInfo.pattern
+    };
+}
+class TextSearchResultsCollector {
+    constructor(_onResult) {
+        this._onResult = _onResult;
+        this._currentFolderIdx = -1;
+        this._currentFileMatch = null;
+        this._batchedCollector = ( new BatchedCollector(512, items => this.sendItems(items)));
+    }
+    add(data, folderIdx) {
+        if (this._currentFileMatch && (this._currentFolderIdx !== folderIdx || !resources.isEqual(this._currentUri, data.uri))) {
+            this.pushToCollector();
+            this._currentFileMatch = null;
+        }
+        if (!this._currentFileMatch) {
+            this._currentFolderIdx = folderIdx;
+            this._currentFileMatch = {
+                resource: data.uri,
+                results: []
+            };
+        }
+        this._currentFileMatch.results.push(extensionResultToFrontendResult(data));
+    }
+    pushToCollector() {
+        const size = this._currentFileMatch && this._currentFileMatch.results ?
+            this._currentFileMatch.results.length :
+            0;
+        this._batchedCollector.addItem(this._currentFileMatch, size);
+    }
+    flush() {
+        this.pushToCollector();
+        this._batchedCollector.flush();
+    }
+    sendItems(items) {
+        this._onResult(items);
+    }
+}
+function extensionResultToFrontendResult(data) {
+    if (extensionResultIsMatch(data)) {
+        return {
+            preview: {
+                matches: mapArrayOrNot(data.preview.matches, m => ({
+                    startLineNumber: m.start.line,
+                    startColumn: m.start.character,
+                    endLineNumber: m.end.line,
+                    endColumn: m.end.character
+                })),
+                text: data.preview.text
+            },
+            ranges: mapArrayOrNot(data.ranges, r => ({
+                startLineNumber: r.start.line,
+                startColumn: r.start.character,
+                endLineNumber: r.end.line,
+                endColumn: r.end.character
+            }))
+        };
+    }
+    else {
+        return {
+            text: data.text,
+            lineNumber: data.lineNumber
+        };
+    }
+}
+function extensionResultIsMatch(data) {
+    return !!data.preview;
+}
+class BatchedCollector {
+    constructor(maxBatchSize, cb) {
+        this.maxBatchSize = maxBatchSize;
+        this.cb = cb;
+        this.totalNumberCompleted = 0;
+        this.batch = [];
+        this.batchSize = 0;
+    }
+    addItem(item, size) {
+        if (!item) {
+            return;
+        }
+        this.addItemToBatch(item, size);
+    }
+    addItems(items, size) {
+        if (!items) {
+            return;
+        }
+        this.addItemsToBatch(items, size);
+    }
+    addItemToBatch(item, size) {
+        this.batch.push(item);
+        this.batchSize += size;
+        this.onUpdate();
+    }
+    addItemsToBatch(item, size) {
+        this.batch = this.batch.concat(item);
+        this.batchSize += size;
+        this.onUpdate();
+    }
+    onUpdate() {
+        if (this.totalNumberCompleted < BatchedCollector.START_BATCH_AFTER_COUNT) {
+            this.flush();
+        }
+        else if (this.batchSize >= this.maxBatchSize) {
+            this.flush();
+        }
+        else if (!this.timeoutHandle) {
+            this.timeoutHandle = setTimeout(() => {
+                this.flush();
+            }, BatchedCollector.TIMEOUT);
+        }
+    }
+    flush() {
+        if (this.batchSize) {
+            this.totalNumberCompleted += this.batchSize;
+            this.cb(this.batch);
+            this.batch = [];
+            this.batchSize = 0;
+            if (this.timeoutHandle) {
+                clearTimeout(this.timeoutHandle);
+                this.timeoutHandle = 0;
+            }
+        }
+    }
+}
+BatchedCollector.TIMEOUT = 4000;
+BatchedCollector.START_BATCH_AFTER_COUNT = 50;
+export { BatchedCollector, TextSearchManager, TextSearchResultsCollector, extensionResultIsMatch };