@codingame/monaco-vscode-api 8.0.3 → 9.0.0

package/vscode/src/vs/workbench/services/search/common/queryBuilder.js

@@ -5,7 +5,7 @@ import { splitGlobAware } from '../../../../base/common/glob.js';
 import { untildify } from '../../../../base/common/labels.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { Schemas } from '../../../../base/common/network.js';
-import { dirname, relative, isAbsolute, normalize, posix } from '../../../../base/common/path.js';
+import { relative, isAbsolute, normalize, posix } from '../../../../base/common/path.js';
 import { isAbsolutePath, isEqual, basename, relativePath } from '../../../../base/common/resources.js';
 import { containsUppercaseCharacter, escapeRegExpCharacters, rtrim } from '../../../../base/common/strings.js';
 import { assertIsDefined, isDefined } from '../../../../base/common/types.js';
@@ -14,18 +14,23 @@ import { isMultilineRegexSource } from '../../../../editor/common/model/textMode
 import { localize } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
 import { toWorkspaceFolder, WorkbenchState } from '../../../../platform/workspace/common/workspace.js';
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
 import { IEditorGroupsService } from '../../editor/common/editorGroupsService.service.js';
 import { IPathService } from '../../path/common/pathService.service.js';
 import { QueryType, pathIncludedInQuery, getExcludes } from './search.js';
+function isISearchPatternBuilder(object) {
+    return (typeof object === 'object' && 'uri' in object && 'pattern' in object);
+}
 let QueryBuilder = class QueryBuilder {
-    constructor(configurationService, workspaceContextService, editorGroupsService, logService, pathService) {
+    constructor(configurationService, workspaceContextService, editorGroupsService, logService, pathService, uriIdentityService) {
         this.configurationService = configurationService;
         this.workspaceContextService = workspaceContextService;
         this.editorGroupsService = editorGroupsService;
         this.logService = logService;
         this.pathService = pathService;
+        this.uriIdentityService = uriIdentityService;
     }
     text(contentPattern, folderResources, options = {}) {
         contentPattern = this.getContentPattern(contentPattern, options);
@@ -42,8 +47,7 @@ let QueryBuilder = class QueryBuilder {
             previewOptions: options.previewOptions,
             maxFileSize: options.maxFileSize,
             usePCRE2: searchConfig.search.usePCRE2 || fallbackToPCRE || false,
-            beforeContext: options.beforeContext,
-            afterContext: options.afterContext,
+            surroundingContext: options.surroundingContext,
             userDisabledExcludesAndIgnoreFiles: options.disregardExcludeSettings && options.disregardIgnoreFiles,
         };
     }
@@ -106,14 +110,24 @@ let QueryBuilder = class QueryBuilder {
         if (!pattern) {
             return {};
         }
-        pattern = Array.isArray(pattern) ? ( (pattern.map(normalizeSlashes))) : normalizeSlashes(pattern);
+        if (Array.isArray(pattern)) {
+            pattern = ( (pattern.filter(p => p.length > 0).map(normalizeSlashes)));
+            if (!pattern.length) {
+                return {};
+            }
+        }
+        else {
+            pattern = normalizeSlashes(pattern);
+        }
         return expandPatterns
             ? this.parseSearchPaths(pattern)
             : { pattern: patternListToIExpression(...(Array.isArray(pattern) ? pattern : [pattern])) };
     }
     commonQuery(folderResources = [], options = {}) {
+        let excludePatterns = Array.isArray(options.excludePattern) ? ( (options.excludePattern.map(p => p.pattern))).flat() : options.excludePattern;
+        excludePatterns = excludePatterns?.length === 1 ? excludePatterns[0] : excludePatterns;
         const includeSearchPathsInfo = this.handleIncludeExclude(options.includePattern, options.expandPatterns);
-        const excludeSearchPathsInfo = this.handleIncludeExclude(options.excludePattern, options.expandPatterns);
+        const excludeSearchPathsInfo = this.handleIncludeExclude(excludePatterns, options.expandPatterns);
         const includeFolderName = folderResources.length > 1;
         const folderQueries = (includeSearchPathsInfo.searchPaths && includeSearchPathsInfo.searchPaths.length ?
             ( (includeSearchPathsInfo.searchPaths.map(
@@ -131,7 +145,8 @@ let QueryBuilder = class QueryBuilder {
             excludePattern: excludeSearchPathsInfo.pattern,
             includePattern: includeSearchPathsInfo.pattern,
             onlyOpenEditors: options.onlyOpenEditors,
-            maxResults: options.maxResults
+            maxResults: options.maxResults,
+            onlyFileScheme: options.onlyFileScheme
         };
         if (options.onlyOpenEditors) {
             const openEditors = coalesce(this.editorGroupsService.groups.flatMap(group => ( (group.editors.map(editor => editor.resource)))));
@@ -156,7 +171,7 @@ let QueryBuilder = class QueryBuilder {
             }
             const providerExists = isAbsolutePath(file);
             if (providerExists) {
-                const searchRoot = this.workspaceContextService.getWorkspaceFolder(file)?.uri ?? file.with({ path: dirname(file.fsPath) });
+                const searchRoot = this.workspaceContextService.getWorkspaceFolder(file)?.uri ?? this.uriIdentityService.extUri.dirname(file);
                 let folderQuery = foldersToSearch.get(searchRoot);
                 if (!folderQuery) {
                     hasIncludedFile = true;
@@ -331,7 +346,7 @@ let QueryBuilder = class QueryBuilder {
             else {
                 const probableWorkspaceFolderNameMatch = searchPath.match(/\.[\/\\](.+)[\/\\]?/);
                 const probableWorkspaceFolderName = probableWorkspaceFolderNameMatch ? probableWorkspaceFolderNameMatch[1] : searchPath;
-                const searchPathNotFoundError = ( localize(4562, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
+                const searchPathNotFoundError = ( localize(4641, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
                 throw ( (new Error(searchPathNotFoundError)));
             }
         }
@@ -369,6 +384,14 @@ let QueryBuilder = class QueryBuilder {
     getFolderQueryForRoot(folder, options, searchPathExcludes, includeFolderName) {
         let thisFolderExcludeSearchPathPattern;
         const folderUri = URI.isUri(folder) ? folder : folder.uri;
+        let excludeFolderRoots = options.excludePattern?.map(excludePattern => {
+            const excludeRoot = options.excludePattern && isISearchPatternBuilder(excludePattern) ? excludePattern.uri : undefined;
+            const shouldUseExcludeRoot = (!excludeRoot || !(URI.isUri(folder) && this.uriIdentityService.extUri.isEqual(folder, excludeRoot)));
+            return shouldUseExcludeRoot ? excludeRoot : undefined;
+        });
+        if (!excludeFolderRoots?.length) {
+            excludeFolderRoots = [undefined];
+        }
         if (searchPathExcludes.searchPaths) {
             const thisFolderExcludeSearchPath = searchPathExcludes.searchPaths.filter(sp => isEqual(sp.searchPath, folderUri))[0];
             if (thisFolderExcludeSearchPath && !thisFolderExcludeSearchPath.pattern) {
@@ -385,10 +408,16 @@ let QueryBuilder = class QueryBuilder {
             ...(thisFolderExcludeSearchPathPattern || {})
         };
         const folderName = URI.isUri(folder) ? basename(folder) : folder.name;
+        const excludePatternRet = ( (excludeFolderRoots.map(excludeFolderRoot => {
+            return ( (Object.keys(excludePattern))).length > 0 ? {
+                folder: excludeFolderRoot,
+                pattern: excludePattern
+            } : undefined;
+        }))).filter((e) => e);
         return {
             folder: folderUri,
             folderName: includeFolderName ? folderName : undefined,
-            excludePattern: ( (Object.keys(excludePattern))).length > 0 ? excludePattern : undefined,
+            excludePattern: excludePatternRet,
             fileEncoding: folderConfig.files && folderConfig.files.encoding,
             disregardIgnoreFiles: typeof options.disregardIgnoreFiles === 'boolean' ? options.disregardIgnoreFiles : !folderConfig.search?.useIgnoreFiles,
             disregardGlobalIgnoreFiles: typeof options.disregardGlobalIgnoreFiles === 'boolean' ? options.disregardGlobalIgnoreFiles : !folderConfig.search?.useGlobalIgnoreFiles,
@@ -402,7 +431,8 @@ QueryBuilder = ( (__decorate([
     ( (__param(1, IWorkspaceContextService))),
     ( (__param(2, IEditorGroupsService))),
     ( (__param(3, ILogService))),
-    ( (__param(4, IPathService)))
+    ( (__param(4, IPathService))),
+    ( (__param(5, IUriIdentityService)))
 ], QueryBuilder)));
 function splitGlobFromPath(searchPath) {
     const globCharMatch = searchPath.match(/[\*\{\}\(\)\[\]\?]/);
@@ -493,4 +523,4 @@ function resolveResourcesForSearchIncludes(resources, contextService) {
     }
     return folderPaths;
 }
-export { QueryBuilder, resolveResourcesForSearchIncludes };
+export { QueryBuilder, isISearchPatternBuilder, resolveResourcesForSearchIncludes };

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

@@ -28,7 +28,7 @@ var QueryType;
     QueryType[QueryType["aiText"] = 3] = "aiText";
 })(QueryType || (QueryType = {})));
 function resultIsMatch(result) {
-    return !!result.preview;
+    return !!result.rangeLocations && !!result.previewText;
 }
 function isFileMatch(p) {
     return !!p.resource;
@@ -48,18 +48,17 @@ class FileMatch {
     }
 }
 class TextSearchMatch {
-    constructor(text, range, previewOptions, webviewIndex) {
-        this.ranges = range;
+    constructor(text, ranges, previewOptions, webviewIndex) {
+        this.rangeLocations = [];
         this.webviewIndex = webviewIndex;
-        const ranges = Array.isArray(range) ? range : [range];
-        if (previewOptions && previewOptions.matchLines === 1 && isSingleLineRangeList(ranges)) {
+        const rangesArr = Array.isArray(ranges) ? ranges : [ranges];
+        if (previewOptions && previewOptions.matchLines === 1 && isSingleLineRangeList(rangesArr)) {
             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) {
+            for (const range of rangesArr) {
                 const previewStart = Math.max(range.startColumn - leadingChars, 0);
                 const previewEnd = range.startColumn + previewOptions.charsPerLine;
                 if (previewStart > lastEnd + leadingChars + SEARCH_ELIDED_MIN_LEN) {
@@ -70,22 +69,27 @@ class TextSearchMatch {
                 else {
                     result += text.slice(lastEnd, previewEnd);
                 }
-                matches.push(( new OneLineRange(0, range.startColumn - shift, range.endColumn - shift)));
                 lastEnd = previewEnd;
+                this.rangeLocations.push({
+                    source: range,
+                    preview: ( new OneLineRange(0, range.startColumn - shift, range.endColumn - shift))
+                });
             }
-            this.preview = { text: result, matches: Array.isArray(this.ranges) ? matches : matches[0] };
+            this.previewText = result;
         }
         else {
-            const firstMatchLine = Array.isArray(range) ? range[0].startLineNumber : range.startLineNumber;
-            this.preview = {
-                text,
-                matches: mapArrayOrNot(range, r => ( new SearchRange(
+            const firstMatchLine = Array.isArray(ranges) ? ranges[0].startLineNumber : ranges.startLineNumber;
+            const rangeLocs = mapArrayOrNot(ranges, r => ({
+                preview: ( new SearchRange(
                     r.startLineNumber - firstMatchLine,
                     r.startColumn,
                     r.endLineNumber - firstMatchLine,
                     r.endColumn
-                )))
-            };
+                )),
+                source: r
+            }));
+            this.rangeLocations = Array.isArray(rangeLocs) ? rangeLocs : [rangeLocs];
+            this.previewText = text;
         }
     }
 }
@@ -206,11 +210,16 @@ function resolvePatternsForProvider(globalPattern, folderPattern) {
 class QueryGlobTester {
     constructor(config, folderQuery) {
         this._parsedIncludeExpression = null;
-        this._excludeExpression = {
-            ...(config.excludePattern || {}),
-            ...(folderQuery.excludePattern || {})
-        };
-        this._parsedExcludeExpression = parse(this._excludeExpression);
+        this._excludeExpression = folderQuery.excludePattern?.map(excludePattern => {
+            return {
+                ...(config.excludePattern || {}),
+                ...(excludePattern.pattern || {})
+            };
+        }) ?? [];
+        if (this._excludeExpression.length === 0) {
+            this._excludeExpression = [config.excludePattern || {}];
+        }
+        this._parsedExcludeExpression = ( this._excludeExpression.map(e => parse(e)));
         let includeExpression = config.includePattern;
         if (folderQuery.includePattern) {
             if (includeExpression) {
@@ -227,14 +236,25 @@ class QueryGlobTester {
             this._parsedIncludeExpression = parse(includeExpression);
         }
     }
+    _evalParsedExcludeExpression(testPath, basename, hasSibling) {
+        let result = null;
+        for (const folderExclude of this._parsedExcludeExpression) {
+            const evaluation = folderExclude(testPath, basename, hasSibling);
+            if (typeof evaluation === 'string') {
+                result = evaluation;
+                break;
+            }
+        }
+        return result;
+    }
     matchesExcludesSync(testPath, basename, hasSibling) {
-        if (this._parsedExcludeExpression && this._parsedExcludeExpression(testPath, basename, hasSibling)) {
+        if (this._parsedExcludeExpression && this._evalParsedExcludeExpression(testPath, basename, hasSibling)) {
             return true;
         }
         return false;
     }
     includedInQuerySync(testPath, basename, hasSibling) {
-        if (this._parsedExcludeExpression && this._parsedExcludeExpression(testPath, basename, hasSibling)) {
+        if (this._parsedExcludeExpression && this._evalParsedExcludeExpression(testPath, basename, hasSibling)) {
             return false;
         }
         if (this._parsedIncludeExpression && !this._parsedIncludeExpression(testPath, basename, hasSibling)) {
@@ -243,24 +263,26 @@ class QueryGlobTester {
         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();
+        return Promise.all(( this._parsedExcludeExpression.map(e => {
+            const excluded = e(testPath, basename, hasSibling);
+            if (isThenable(excluded)) {
+                return excluded.then(excluded => {
+                    if (excluded) {
+                        return false;
+                    }
+                    return isIncluded();
+                });
+            }
+            return isIncluded();
+        }))).then(e => ( e.some(e => !!e)));
     }
     hasSiblingExcludeClauses() {
-        return hasSiblingClauses(this._excludeExpression);
+        return this._excludeExpression.reduce((prev, curr) => hasSiblingClauses(curr) || prev, false);
     }
 }
 function hasSiblingClauses(pattern) {
@@ -304,4 +326,17 @@ function listToMap(list) {
     }
     return map;
 }
-export { DEFAULT_MAX_SEARCH_RESULTS, FileMatch, OneLineRange, QueryGlobTester, QueryType, SEARCH_EXCLUDE_CONFIG, SEARCH_RESULT_LANGUAGE_ID, SearchCompletionExitCode, SearchError, SearchErrorCode, SearchProviderType, SearchRange, SearchSortOrder, TextSearchMatch, VIEWLET_ID, VIEW_ID, ViewMode, deserializeSearchError, getExcludes, hasSiblingFn, hasSiblingPromiseFn, isFileMatch, isProgressMessage, pathIncludedInQuery, resolvePatternsForProvider, resultIsMatch };
+function excludeToGlobPattern(excludesForFolder) {
+    return excludesForFolder.flatMap(exclude => ( exclude.patterns.map(pattern => {
+        return exclude.baseUri ?
+            {
+                baseUri: exclude.baseUri,
+                pattern: pattern
+            } : pattern;
+    })));
+}
+const DEFAULT_TEXT_SEARCH_PREVIEW_OPTIONS = {
+    matchLines: 100,
+    charsPerLine: 10000
+};
+export { DEFAULT_MAX_SEARCH_RESULTS, DEFAULT_TEXT_SEARCH_PREVIEW_OPTIONS, FileMatch, OneLineRange, QueryGlobTester, QueryType, SEARCH_EXCLUDE_CONFIG, SEARCH_RESULT_LANGUAGE_ID, SearchCompletionExitCode, SearchError, SearchErrorCode, SearchProviderType, SearchRange, SearchSortOrder, TextSearchMatch, VIEWLET_ID, VIEW_ID, ViewMode, deserializeSearchError, excludeToGlobPattern, getExcludes, hasSiblingFn, hasSiblingPromiseFn, isFileMatch, isProgressMessage, pathIncludedInQuery, resolvePatternsForProvider, resultIsMatch };

package/vscode/src/vs/workbench/services/search/common/searchExtConversionTypes.js

@@ -0,0 +1,144 @@
+import { coalesce, asArray } from '../../../../base/common/arrays.js';
+import { DEFAULT_TEXT_SEARCH_PREVIEW_OPTIONS } from './search.js';
+import { TextSearchMatchNew, TextSearchContextNew } from './searchExtTypes.js';
+function isTextSearchMatch(object) {
+    return 'uri' in object && 'ranges' in object && 'preview' in object;
+}
+function newToOldFileProviderOptions(options) {
+    return ( options.folderOptions.map(folderOption => ({
+        folder: folderOption.folder,
+        excludes: ( folderOption.excludes.map(e => typeof (e) === 'string' ? e : e.pattern)),
+        includes: folderOption.includes,
+        useGlobalIgnoreFiles: folderOption.useIgnoreFiles.global,
+        useIgnoreFiles: folderOption.useIgnoreFiles.local,
+        useParentIgnoreFiles: folderOption.useIgnoreFiles.parent,
+        followSymlinks: folderOption.followSymlinks,
+        maxResults: options.maxResults,
+        session: options.session
+    })));
+}
+class OldFileSearchProviderConverter {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    provideFileSearchResults(pattern, options, token) {
+        const getResult = async () => {
+            const newOpts = newToOldFileProviderOptions(options);
+            return Promise.all(( newOpts.map(o => this.provider.provideFileSearchResults({ pattern }, o, token))));
+        };
+        return getResult().then(e => coalesce(e).flat());
+    }
+}
+function newToOldTextProviderOptions(options) {
+    return ( options.folderOptions.map(folderOption => ({
+        folder: folderOption.folder,
+        excludes: ( folderOption.excludes.map(e => typeof (e) === 'string' ? e : e.pattern)),
+        includes: folderOption.includes,
+        useGlobalIgnoreFiles: folderOption.useIgnoreFiles.global,
+        useIgnoreFiles: folderOption.useIgnoreFiles.local,
+        useParentIgnoreFiles: folderOption.useIgnoreFiles.parent,
+        followSymlinks: folderOption.followSymlinks,
+        maxResults: options.maxResults,
+        previewOptions: newToOldPreviewOptions(options.previewOptions),
+        maxFileSize: options.maxFileSize,
+        encoding: folderOption.encoding,
+        afterContext: options.surroundingContext,
+        beforeContext: options.surroundingContext
+    })));
+}
+function newToOldPreviewOptions(options) {
+    return {
+        matchLines: options?.matchLines ?? DEFAULT_TEXT_SEARCH_PREVIEW_OPTIONS.matchLines,
+        charsPerLine: options?.charsPerLine ?? DEFAULT_TEXT_SEARCH_PREVIEW_OPTIONS.charsPerLine
+    };
+}
+function oldToNewTextSearchResult(result) {
+    if (isTextSearchMatch(result)) {
+        const ranges = ( asArray(result.ranges).map((r, i) => {
+            const previewArr = asArray(result.preview.matches);
+            const matchingPreviewRange = previewArr[i];
+            return { sourceRange: r, previewRange: matchingPreviewRange };
+        }));
+        return ( new TextSearchMatchNew(result.uri, ranges, result.preview.text));
+    }
+    else {
+        return ( new TextSearchContextNew(result.uri, result.text, result.lineNumber));
+    }
+}
+class OldTextSearchProviderConverter {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    provideTextSearchResults(query, options, progress, token) {
+        const progressShim = (oldResult) => {
+            if (!validateProviderResult(oldResult)) {
+                return;
+            }
+            progress.report(oldToNewTextSearchResult(oldResult));
+        };
+        const getResult = async () => {
+            return coalesce(await Promise.all(( newToOldTextProviderOptions(options).map(
+                o => this.provider.provideTextSearchResults(query, o, { report: (e) => progressShim(e) }, token)
+            ))))
+                .reduce((prev, cur) => ({ limitHit: prev.limitHit || cur.limitHit }), { limitHit: false });
+        };
+        const oldResult = getResult();
+        return oldResult.then((e) => {
+            return {
+                limitHit: e.limitHit,
+                message: coalesce(asArray(e.message))
+            };
+        });
+    }
+}
+class OldAITextSearchProviderConverter {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    provideAITextSearchResults(query, options, progress, token) {
+        const progressShim = (oldResult) => {
+            if (!validateProviderResult(oldResult)) {
+                return;
+            }
+            progress.report(oldToNewTextSearchResult(oldResult));
+        };
+        const getResult = async () => {
+            return coalesce(await Promise.all(( newToOldTextProviderOptions(options).map(
+                o => this.provider.provideAITextSearchResults(query, o, { report: (e) => progressShim(e) }, token)
+            ))))
+                .reduce((prev, cur) => ({ limitHit: prev.limitHit || cur.limitHit }), { limitHit: false });
+        };
+        const oldResult = getResult();
+        return oldResult.then((e) => {
+            return {
+                limitHit: e.limitHit,
+                message: coalesce(asArray(e.message))
+            };
+        });
+    }
+}
+function 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;
+}
+function extensionResultIsMatch(data) {
+    return !!data.preview;
+}
+export { OldAITextSearchProviderConverter, OldFileSearchProviderConverter, OldTextSearchProviderConverter, extensionResultIsMatch, newToOldPreviewOptions, oldToNewTextSearchResult };

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

@@ -1,9 +1,3 @@
-import { asArray } from '../../../../base/common/arrays.js';
-var TextSearchCompleteMessageType;
-( (function(TextSearchCompleteMessageType) {
-    TextSearchCompleteMessageType[TextSearchCompleteMessageType["Information"] = 1] = "Information";
-    TextSearchCompleteMessageType[TextSearchCompleteMessageType["Warning"] = 2] = "Warning";
-})(TextSearchCompleteMessageType || (TextSearchCompleteMessageType = {})));
 class TextSearchMatchNew {
     constructor(uri, ranges, previewText) {
         this.uri = uri;
@@ -20,27 +14,13 @@ class TextSearchContextNew {
 }
 var ExcludeSettingOptions;
 ( (function(ExcludeSettingOptions) {
-    ExcludeSettingOptions[ExcludeSettingOptions["none"] = 1] = "none";
-    ExcludeSettingOptions[ExcludeSettingOptions["filesExclude"] = 2] = "filesExclude";
-    ExcludeSettingOptions[ExcludeSettingOptions["searchAndFilesExclude"] = 3] = "searchAndFilesExclude";
+    ExcludeSettingOptions[ExcludeSettingOptions["None"] = 1] = "None";
+    ExcludeSettingOptions[ExcludeSettingOptions["FilesExclude"] = 2] = "FilesExclude";
+    ExcludeSettingOptions[ExcludeSettingOptions["SearchAndFilesExclude"] = 3] = "SearchAndFilesExclude";
 })(ExcludeSettingOptions || (ExcludeSettingOptions = {})));
-var TextSearchCompleteMessageTypeNew;
-( (function(TextSearchCompleteMessageTypeNew) {
-    TextSearchCompleteMessageTypeNew[TextSearchCompleteMessageTypeNew["Information"] = 1] = "Information";
-    TextSearchCompleteMessageTypeNew[TextSearchCompleteMessageTypeNew["Warning"] = 2] = "Warning";
-})(
-    TextSearchCompleteMessageTypeNew || (TextSearchCompleteMessageTypeNew = {})
-));
-function isTextSearchMatch(object) {
-    return 'uri' in object && 'ranges' in object && 'preview' in object;
-}
-function oldToNewTextSearchResult(result) {
-    if (isTextSearchMatch(result)) {
-        const ranges = ( asArray(result.ranges).map(r => ({ sourceRange: r, previewRange: r })));
-        return ( new TextSearchMatchNew(result.uri, ranges, result.preview.text));
-    }
-    else {
-        return ( new TextSearchContextNew(result.uri, result.text, result.lineNumber));
-    }
-}
-export { ExcludeSettingOptions, TextSearchCompleteMessageType, TextSearchCompleteMessageTypeNew, TextSearchContextNew, TextSearchMatchNew, oldToNewTextSearchResult };
+var TextSearchCompleteMessageType;
+( (function(TextSearchCompleteMessageType) {
+    TextSearchCompleteMessageType[TextSearchCompleteMessageType["Information"] = 1] = "Information";
+    TextSearchCompleteMessageType[TextSearchCompleteMessageType["Warning"] = 2] = "Warning";
+})(TextSearchCompleteMessageType || (TextSearchCompleteMessageType = {})));
+export { ExcludeSettingOptions, TextSearchCompleteMessageType, TextSearchContextNew, TextSearchMatchNew };

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

@@ -35,8 +35,8 @@ function getTextSearchMatchWithModelContext(matches, model, query) {
     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);
+        if (typeof query.surroundingContext === 'number' && query.surroundingContext > 0) {
+            const beforeContextStartLine = Math.max(prevLine + 1, matchStartLine - query.surroundingContext);
             for (let b = beforeContextStartLine; b < matchStartLine; b++) {
                 results.push({
                     text: model.getLineContent(b + 1),
@@ -47,8 +47,8 @@ function getTextSearchMatchWithModelContext(matches, model, query) {
         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);
+        if (typeof query.surroundingContext === 'number' && query.surroundingContext > 0) {
+            const afterContextToLine = Math.min(nextMatchStartLine - 1, matchEndLine + query.surroundingContext, model.getLineCount() - 1);
             for (let a = matchEndLine + 1; a <= afterContextToLine; a++) {
                 results.push({
                     text: model.getLineContent(a + 1),
@@ -61,9 +61,9 @@ function getTextSearchMatchWithModelContext(matches, model, query) {
     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;
+    const matchRanges = ( match.rangeLocations.map(e => e.source));
+    const matchStartLine = matchRanges[0].startLineNumber;
+    const matchEndLine = matchRanges[matchRanges.length - 1].endLineNumber;
     return {
         start: matchStartLine,
         end: matchEndLine