@codingame/monaco-vscode-api 9.0.3 → 10.0.1

package/vscode/src/vs/workbench/contrib/search/browser/searchModel.js

@@ -13,15 +13,13 @@ import { lcut } from '../../../../base/common/strings.js';
 import { TernarySearchTree } from '../../../../base/common/ternarySearchTree.js';
 import { URI } from '../../../../base/common/uri.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { TrackedRangeStickiness, OverviewRulerLane, MinimapPosition, FindMatch } from '../../../../editor/common/model.js';
+import { OverviewRulerLane, FindMatch } from '../../../../editor/common/model.js';
 import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
 import { IModelService } from '../../../../editor/common/services/model.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILabelService } from '../../../../platform/label/common/label.service.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
-import { ProgressLocation } from '../../../../platform/progress/common/progress.js';
-import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 import '../../../../platform/theme/common/colorUtils.js';
 import '../../../../platform/theme/common/colors/baseColors.js';
@@ -45,7 +43,7 @@ import { isINotebookFileMatchWithModel, contentMatchesToTextSearchMatches, webvi
 import { INotebookSearchService } from '../common/notebookSearch.service.js';
 import { isINotebookFileMatchNoModel, rawCellPrefix } from '../common/searchNotebookHelpers.js';
 import { ReplacePattern } from '../../../services/search/common/replace.js';
-import { resultIsMatch, DEFAULT_MAX_SEARCH_RESULTS, OneLineRange, SearchSortOrder, QueryType, SearchCompletionExitCode } from '../../../services/search/common/search.js';
+import { OneLineRange, resultIsMatch, DEFAULT_MAX_SEARCH_RESULTS } from '../../../services/search/common/search.js';
 import { ISearchService } from '../../../services/search/common/search.service.js';
 import { editorMatchesToTextSearchResults, getTextSearchMatchWithModelContext } from '../../../services/search/common/searchHelpers.js';
 import { CellSearchModel } from '../common/cellSearchModel.js';
@@ -154,6 +152,9 @@ class Match {
     getMatchString() {
         return this._oneLinePreviewText.substring(this._rangeInPreviewText.startColumn - 1, this._rangeInPreviewText.endColumn - 1);
     }
+    isReadonly() {
+        return this.aiContributed;
+    }
 }
 Match.__decorator = ( __decorate([
     memoize
@@ -255,7 +256,7 @@ class MatchInNotebook extends Match {
         return this._webviewIndex !== undefined;
     }
     isReadonly() {
-        return (!this._cellParent.hasCellViewModel()) || this.isWebviewMatch();
+        return super.isReadonly() || (!this._cellParent.hasCellViewModel()) || this.isWebviewMatch();
     }
     get cellIndex() {
         return this._cellParent.cellIndex;
@@ -271,7 +272,7 @@ let FileMatch = class FileMatch extends Disposable {
     static { FileMatch_1 = this; }
     static { this._CURRENT_FIND_MATCH = ModelDecorationOptions.register({
         description: 'search-current-find-match',
-        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+        stickiness: 1 ,
         zIndex: 13,
         className: 'currentFindMatch',
         overviewRuler: {
@@ -280,12 +281,12 @@ let FileMatch = class FileMatch extends Disposable {
         },
         minimap: {
             color: themeColorFromId(minimapFindMatch),
-            position: MinimapPosition.Inline
+            position: 1
         }
     }); }
     static { this._FIND_MATCH = ModelDecorationOptions.register({
         description: 'search-find-match',
-        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+        stickiness: 1 ,
         className: 'findMatch',
         overviewRuler: {
             color: themeColorFromId(overviewRulerFindMatchForeground),
@@ -293,7 +294,7 @@ let FileMatch = class FileMatch extends Disposable {
         },
         minimap: {
             color: themeColorFromId(minimapFindMatch),
-            position: MinimapPosition.Inline
+            position: 1
         }
     }); }
     static getDecorationOption(selected) {
@@ -370,7 +371,7 @@ let FileMatch = class FileMatch extends Disposable {
         return this._closestRoot;
     }
     hasReadonlyMatches() {
-        return ( this.matches().some(m => m instanceof MatchInNotebook && m.isReadonly()));
+        return ( this.matches().some(m => m.isReadonly()));
     }
     createMatches(isAiContributed) {
         const model = this.modelService.getModel(this._resource);
@@ -483,6 +484,9 @@ let FileMatch = class FileMatch extends Disposable {
     parent() {
         return this._parent;
     }
+    get hasChildren() {
+        return this._textMatches.size > 0 || this._cellMatches.size > 0;
+    }
     matches() {
         const cellMatches = Array.from(( this._cellMatches.values())).flatMap((e) => e.matches());
         return [...( this._textMatches.values()), ...cellMatches];
@@ -592,7 +596,7 @@ let FileMatch = class FileMatch extends Disposable {
         super.dispose();
     }
     hasOnlyReadOnlyMatches() {
-        return this.matches().every(match => (match instanceof MatchInNotebook && match.isReadonly()));
+        return this.matches().every(match => match.isReadonly());
     }
     bindNotebookEditorWidget(widget) {
         if (this._notebookEditorWidget === widget) {
@@ -816,6 +820,9 @@ let FolderMatch = FolderMatch_1 = class FolderMatch extends Disposable {
     parent() {
         return this._parent;
     }
+    get hasChildren() {
+        return this._fileMatches.size > 0 || this._folderMatches.size > 0;
+    }
     bindModel(model) {
         const fileMatch = this._fileMatches.get(model.uri);
         if (fileMatch) {
@@ -1120,7 +1127,7 @@ FolderMatchWithResource = ( __decorate([
 ], FolderMatchWithResource));
 let FolderMatchWorkspaceRoot = class FolderMatchWorkspaceRoot extends FolderMatchWithResource {
     constructor(_resource, _id, _index, _query, _parent, _ai, replaceService, instantiationService, labelService, uriIdentityService) {
-        super(_resource, _id, _index, _query, _parent, _parent, null, replaceService, instantiationService, labelService, uriIdentityService);
+        super(_resource, _id, _index, _query, _parent, _parent.parent(), null, replaceService, instantiationService, labelService, uriIdentityService);
         this._ai = _ai;
     }
     normalizedUriParent(uri) {
@@ -1171,7 +1178,7 @@ FolderMatchWorkspaceRoot = ( __decorate([
 ], FolderMatchWorkspaceRoot));
 let FolderMatchNoRoot = class FolderMatchNoRoot extends FolderMatch {
     constructor(_id, _index, _query, _parent, replaceService, instantiationService, labelService, uriIdentityService) {
-        super(null, _id, _index, _query, _parent, _parent, null, replaceService, instantiationService, labelService, uriIdentityService);
+        super(null, _id, _index, _query, _parent, _parent.parent(), null, replaceService, instantiationService, labelService, uriIdentityService);
     }
     createAndConfigureFileMatch(rawFileMatch, searchInstanceID) {
         const fileMatch = this._register(this.instantiationService.createInstance(FileMatch, this._query.contentPattern, this._query.previewOptions, this._query.maxResults, this, rawFileMatch, null, searchInstanceID));
@@ -1188,9 +1195,264 @@ FolderMatchNoRoot = ( __decorate([
     ( __param(6, ILabelService)),
     ( __param(7, IUriIdentityService))
 ], FolderMatchNoRoot));
+let TextSearchResult = class TextSearchResult extends Disposable {
+    constructor(_allowOtherResults, _parent, _id, instantiationService, uriIdentityService) {
+        super();
+        this._allowOtherResults = _allowOtherResults;
+        this._parent = _parent;
+        this._id = _id;
+        this.instantiationService = instantiationService;
+        this.uriIdentityService = uriIdentityService;
+        this._onChange = this._register(( new Emitter()));
+        this.onChange = this._onChange.event;
+        this._isDirty = false;
+        this._showHighlights = false;
+        this._query = null;
+        this.disposePastResults = () => Promise.resolve();
+        this._folderMatches = [];
+        this._otherFilesMatch = null;
+        this._folderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
+        this.resource = null;
+        this.hidden = false;
+        this._rangeHighlightDecorations = this.instantiationService.createInstance(RangeHighlightDecorations);
+        this._register(this.onChange(e => {
+            if (e.removed) {
+                this._isDirty = !this.isEmpty();
+            }
+        }));
+    }
+    hide() {
+        this.hidden = true;
+        this.clear();
+    }
+    get isAIContributed() {
+        return this.id() === AI_TEXT_SEARCH_RESULT_ID;
+    }
+    id() {
+        return this._id;
+    }
+    parent() {
+        return this._parent;
+    }
+    get hasChildren() {
+        return this._folderMatches.length > 0;
+    }
+    name() {
+        return this._id === AI_TEXT_SEARCH_RESULT_ID ? 'AI' : 'Text';
+    }
+    get isDirty() {
+        return this._isDirty;
+    }
+    getFolderMatch(resource) {
+        const folderMatch = this._folderMatchesMap.findSubstr(resource);
+        if (!folderMatch && this._allowOtherResults && this._otherFilesMatch) {
+            return this._otherFilesMatch;
+        }
+        return folderMatch;
+    }
+    add(allRaw, searchInstanceID, ai, silent = false) {
+        const { byFolder, other } = this.groupFilesByFolder(allRaw);
+        byFolder.forEach(raw => {
+            if (!raw.length) {
+                return;
+            }
+            const folderMatch = this.getFolderMatch(raw[0].resource);
+            folderMatch?.addFileMatch(raw, silent, searchInstanceID, this.isAIContributed);
+        });
+        if (!ai) {
+            this._otherFilesMatch?.addFileMatch(other, silent, searchInstanceID, false);
+        }
+        this.disposePastResults();
+    }
+    remove(matches, ai = false) {
+        if (!Array.isArray(matches)) {
+            matches = [matches];
+        }
+        matches.forEach(m => {
+            if (m instanceof FolderMatch) {
+                m.clear();
+            }
+        });
+        const fileMatches = matches.filter(m => m instanceof FileMatch);
+        const { byFolder, other } = this.groupFilesByFolder(fileMatches);
+        byFolder.forEach(matches => {
+            if (!matches.length) {
+                return;
+            }
+            this.getFolderMatch(matches[0].resource)?.remove(matches);
+        });
+        if (other.length) {
+            this.getFolderMatch(other[0].resource)?.remove(other);
+        }
+    }
+    groupFilesByFolder(fileMatches) {
+        const rawPerFolder = ( new ResourceMap());
+        const otherFileMatches = [];
+        this._folderMatches.forEach(fm => rawPerFolder.set(fm.resource, []));
+        fileMatches.forEach(rawFileMatch => {
+            const folderMatch = this.getFolderMatch(rawFileMatch.resource);
+            if (!folderMatch) {
+                return;
+            }
+            const resource = folderMatch.resource;
+            if (resource) {
+                rawPerFolder.get(resource).push(rawFileMatch);
+            }
+            else {
+                otherFileMatches.push(rawFileMatch);
+            }
+        });
+        return {
+            byFolder: rawPerFolder,
+            other: otherFileMatches
+        };
+    }
+    isEmpty() {
+        return this.folderMatches().every((folderMatch) => folderMatch.isEmpty());
+    }
+    findFolderSubstr(resource) {
+        return this._folderMatchesMap.findSubstr(resource);
+    }
+    get query() {
+        return this._query;
+    }
+    set query(query) {
+        const oldFolderMatches = this.folderMatches();
+        this.disposePastResults = async () => {
+            oldFolderMatches.forEach(match => match.clear());
+            oldFolderMatches.forEach(match => match.dispose());
+            this._isDirty = false;
+        };
+        this.cachedSearchComplete = undefined;
+        this._rangeHighlightDecorations.removeHighlightRange();
+        this._folderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
+        if (!query) {
+            return;
+        }
+        this._folderMatches = ( ( (query && query.folderQueries || [])
+            .map(fq => fq.folder))
+            .map((resource, index) => this._createBaseFolderMatch(resource, ( resource.toString()), index, query, this.isAIContributed)));
+        this._folderMatches.forEach(fm => this._folderMatchesMap.set(fm.resource, fm));
+        if (this._allowOtherResults) {
+            this._otherFilesMatch = this._createBaseFolderMatch(null, 'otherFiles', this._folderMatches.length + 1, query, this.isAIContributed);
+        }
+        this._query = query;
+    }
+    _createBaseFolderMatch(resource, id, index, query, ai) {
+        let folderMatch;
+        if (resource) {
+            folderMatch = this._register(this.instantiationService.createInstance(FolderMatchWorkspaceRoot, resource, id, index, query, this, ai));
+        }
+        else {
+            folderMatch = this._register(this.instantiationService.createInstance(FolderMatchNoRoot, id, index, query, this));
+        }
+        const disposable = folderMatch.onChange((event) => this._onChange.fire(event));
+        this._register(folderMatch.onDispose(() => disposable.dispose()));
+        return folderMatch;
+    }
+    folderMatches() {
+        return this._otherFilesMatch && this._allowOtherResults ?
+            [
+                ...this._folderMatches,
+                this._otherFilesMatch,
+            ] :
+            this._folderMatches;
+    }
+    disposeMatches() {
+        this.folderMatches().forEach(folderMatch => folderMatch.dispose());
+        this._folderMatches = [];
+        this._folderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
+        this._rangeHighlightDecorations.removeHighlightRange();
+    }
+    matches() {
+        const matches = [];
+        this.folderMatches().forEach(folderMatch => {
+            matches.push(folderMatch.allDownstreamFileMatches());
+        });
+        return [].concat(...matches);
+    }
+    get showHighlights() {
+        return this._showHighlights;
+    }
+    toggleHighlights(value) {
+        if (this._showHighlights === value) {
+            return;
+        }
+        this._showHighlights = value;
+        let selectedMatch = null;
+        this.matches().forEach((fileMatch) => {
+            fileMatch.updateHighlights();
+            fileMatch.updateNotebookHighlights();
+            if (!selectedMatch) {
+                selectedMatch = fileMatch.getSelectedMatch();
+            }
+        });
+        if (this._showHighlights && selectedMatch) {
+            this._rangeHighlightDecorations.highlightRange(selectedMatch.parent().resource, selectedMatch.range());
+        }
+        else {
+            this._rangeHighlightDecorations.removeHighlightRange();
+        }
+    }
+    get rangeHighlightDecorations() {
+        return this._rangeHighlightDecorations;
+    }
+    fileCount() {
+        return this.folderMatches().reduce((prev, match) => prev + match.recursiveFileCount(), 0);
+    }
+    count() {
+        return this.matches().reduce((prev, match) => prev + match.count(), 0);
+    }
+    clear() {
+        this.folderMatches().forEach((folderMatch) => folderMatch.clear(true));
+        this.disposeMatches();
+        this._folderMatches = [];
+        this._otherFilesMatch = null;
+        this.cachedSearchComplete = undefined;
+    }
+    async dispose() {
+        this._rangeHighlightDecorations.dispose();
+        this.disposeMatches();
+        super.dispose();
+        await this.disposePastResults();
+    }
+};
+TextSearchResult = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IUriIdentityService))
+], TextSearchResult));
+let ReplaceableTextSearchResult = class ReplaceableTextSearchResult extends TextSearchResult {
+    constructor(_allowOtherResults, parent, id, instantiationService, uriIdentityService, replaceService) {
+        super(_allowOtherResults, parent, id, instantiationService, uriIdentityService);
+        this.replaceService = replaceService;
+    }
+    replace(match) {
+        return this.getFolderMatch(match.resource)?.replace(match) ?? Promise.resolve();
+    }
+    replaceAll(progress) {
+        this.replacingAll = true;
+        const promise = this.replaceService.replace(this.matches(), progress);
+        return promise.then(() => {
+            this.replacingAll = false;
+            this.clear();
+        }, () => {
+            this.replacingAll = false;
+        });
+    }
+    set replacingAll(running) {
+        this.folderMatches().forEach((folderMatch) => {
+            folderMatch.replacingAll = running;
+        });
+    }
+};
+ReplaceableTextSearchResult = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IUriIdentityService)),
+    ( __param(5, IReplaceService))
+], ReplaceableTextSearchResult));
 let elemAIndex = -1;
 let elemBIndex = -1;
-function searchMatchComparer(elementA, elementB, sortOrder = SearchSortOrder.Default) {
+function searchMatchComparer(elementA, elementB, sortOrder = "default" ) {
     if (elementA instanceof FileMatch && elementB instanceof FolderMatch) {
         return 1;
     }
@@ -1204,13 +1466,13 @@ function searchMatchComparer(elementA, elementB, sortOrder = SearchSortOrder.Def
             return elemAIndex - elemBIndex;
         }
         switch (sortOrder) {
-            case SearchSortOrder.CountDescending:
+            case "countDescending" :
                 return elementB.count() - elementA.count();
-            case SearchSortOrder.CountAscending:
+            case "countAscending" :
                 return elementA.count() - elementB.count();
-            case SearchSortOrder.Type:
+            case "type" :
                 return compareFileExtensions(elementA.name(), elementB.name());
-            case SearchSortOrder.FileNames:
+            case "fileNames" :
                 return compareFileNames(elementA.name(), elementB.name());
             default:
                 if (!elementA.resource || !elementB.resource) {
@@ -1221,15 +1483,15 @@ function searchMatchComparer(elementA, elementB, sortOrder = SearchSortOrder.Def
     }
     if (elementA instanceof FileMatch && elementB instanceof FileMatch) {
         switch (sortOrder) {
-            case SearchSortOrder.CountDescending:
+            case "countDescending" :
                 return elementB.count() - elementA.count();
-            case SearchSortOrder.CountAscending:
+            case "countAscending" :
                 return elementA.count() - elementB.count();
-            case SearchSortOrder.Type:
+            case "type" :
                 return compareFileExtensions(elementA.name(), elementB.name());
-            case SearchSortOrder.FileNames:
+            case "fileNames" :
                 return compareFileNames(elementA.name(), elementB.name());
-            case SearchSortOrder.Modified: {
+            case "modified" : {
                 const fileStatA = elementA.fileStat;
                 const fileStatB = elementB.fileStat;
                 if (fileStatA && fileStatB) {
@@ -1272,7 +1534,7 @@ function compareNotebookPos(match1, match2) {
         return 1;
     }
 }
-function searchComparer(elementA, elementB, sortOrder = SearchSortOrder.Default) {
+function searchComparer(elementA, elementB, sortOrder = "default" ) {
     const elemAParents = createParentList(elementA);
     const elemBParents = createParentList(elementB);
     let i = elemAParents.length - 1;
@@ -1297,35 +1559,29 @@ function searchComparer(elementA, elementB, sortOrder = SearchSortOrder.Default)
 function createParentList(element) {
     const parentArray = [];
     let currElement = element;
-    while (!(currElement instanceof SearchResult)) {
+    while (!(currElement instanceof TextSearchResult)) {
         parentArray.push(currElement);
         currElement = currElement.parent();
     }
     return parentArray;
 }
+const PLAIN_TEXT_SEARCH__RESULT_ID = 'plainTextSearch';
+const AI_TEXT_SEARCH_RESULT_ID = 'aiTextSearch';
 let SearchResult = class SearchResult extends Disposable {
-    constructor(searchModel, replaceService, instantiationService, modelService, uriIdentityService, notebookEditorService) {
+    constructor(searchModel, instantiationService, modelService, notebookEditorService) {
         super();
         this.searchModel = searchModel;
-        this.replaceService = replaceService;
         this.instantiationService = instantiationService;
         this.modelService = modelService;
-        this.uriIdentityService = uriIdentityService;
         this.notebookEditorService = notebookEditorService;
         this._onChange = this._register(( new PauseableEmitter({
             merge: mergeSearchResultEvents
         })));
         this.onChange = this._onChange.event;
-        this._folderMatches = [];
-        this._aiFolderMatches = [];
-        this._otherFilesMatch = null;
-        this._folderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
-        this._aiFolderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
-        this._showHighlights = false;
-        this._query = null;
-        this.disposePastResults = () => Promise.resolve();
-        this._isDirty = false;
-        this._rangeHighlightDecorations = this.instantiationService.createInstance(RangeHighlightDecorations);
+        this._plainTextSearchResult = this._register(this.instantiationService.createInstance(ReplaceableTextSearchResult, true, this, PLAIN_TEXT_SEARCH__RESULT_ID));
+        this._aiTextSearchResult = this._register(this.instantiationService.createInstance(TextSearchResult, true, this, AI_TEXT_SEARCH_RESULT_ID));
+        this._register(this._plainTextSearchResult.onChange((e) => this._onChange.fire(e)));
+        this._register(this._aiTextSearchResult.onChange((e) => this._onChange.fire(e)));
         this.modelService.getModels().forEach(model => this.onModelAdded(model));
         this._register(this.modelService.onModelAdded(model => this.onModelAdded(model)));
         this._register(this.notebookEditorService.onDidAddNotebookEditor(widget => {
@@ -1333,11 +1589,21 @@ let SearchResult = class SearchResult extends Disposable {
                 this.onDidAddNotebookEditorWidget(widget);
             }
         }));
-        this._register(this.onChange(e => {
-            if (e.removed) {
-                this._isDirty = !this.isEmpty() || !this.isEmpty(true);
-            }
-        }));
+    }
+    get plainTextSearchResult() {
+        return this._plainTextSearchResult;
+    }
+    get aiTextSearchResult() {
+        return this._aiTextSearchResult;
+    }
+    get children() {
+        return this.textSearchResults;
+    }
+    get hasChildren() {
+        return true;
+    }
+    get textSearchResults() {
+        return [this._plainTextSearchResult, this._aiTextSearchResult];
     }
     async batchReplace(elementsToReplace) {
         try {
@@ -1368,8 +1634,13 @@ let SearchResult = class SearchResult extends Disposable {
             this._onChange.pause();
             elementsToRemove.forEach((currentElement) => {
                 if (!arrayContainsElementOrParent(currentElement, removedElems)) {
-                    currentElement.parent().remove(currentElement);
-                    removedElems.push(currentElement);
+                    if (currentElement instanceof TextSearchResult) {
+                        currentElement.hide();
+                    }
+                    else {
+                        currentElement.parent().remove(currentElement);
+                        removedElems.push(currentElement);
+                    }
                 }
             });
         }
@@ -1378,47 +1649,14 @@ let SearchResult = class SearchResult extends Disposable {
         }
     }
     get isDirty() {
-        return this._isDirty;
+        return this._aiTextSearchResult.isDirty || this._plainTextSearchResult.isDirty;
     }
     get query() {
-        return this._query;
+        return this._plainTextSearchResult.query;
     }
     set query(query) {
-        const oldFolderMatches = this.folderMatches();
-        this.disposePastResults = async () => {
-            oldFolderMatches.forEach(match => match.clear());
-            oldFolderMatches.forEach(match => match.dispose());
-            this._isDirty = false;
-        };
-        this._cachedSearchComplete = undefined;
-        this._aiCachedSearchComplete = undefined;
-        this._rangeHighlightDecorations.removeHighlightRange();
-        this._folderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
-        this._aiFolderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
-        if (!query) {
-            return;
-        }
-        this._folderMatches = ( ( (query && query.folderQueries || [])
-            .map(fq => fq.folder))
-            .map((resource, index) => this._createBaseFolderMatch(resource, ( resource.toString()), index, query, false)));
-        this._folderMatches.forEach(fm => this._folderMatchesMap.set(fm.resource, fm));
-        this._aiFolderMatches = ( ( (query && query.folderQueries || [])
-            .map(fq => fq.folder))
-            .map((resource, index) => this._createBaseFolderMatch(resource, ( resource.toString()), index, query, true)));
-        this._aiFolderMatches.forEach(fm => this._aiFolderMatchesMap.set(fm.resource, fm));
-        this._otherFilesMatch = this._createBaseFolderMatch(null, 'otherFiles', this._folderMatches.length + this._aiFolderMatches.length + 1, query, false);
-        this._query = query;
-    }
-    setCachedSearchComplete(cachedSearchComplete, ai) {
-        if (ai) {
-            this._aiCachedSearchComplete = cachedSearchComplete;
-        }
-        else {
-            this._cachedSearchComplete = cachedSearchComplete;
-        }
-    }
-    getCachedSearchComplete(ai) {
-        return ai ? this._aiCachedSearchComplete : this._cachedSearchComplete;
+        this._plainTextSearchResult.query = query;
+        this._aiTextSearchResult.query = query;
     }
     onDidAddNotebookEditorWidget(widget) {
         this._onWillChangeModelListener?.dispose();
@@ -1434,200 +1672,108 @@ let SearchResult = class SearchResult extends Disposable {
             }
         });
     }
+    folderMatches(ai = false) {
+        if (ai) {
+            return this._aiTextSearchResult.folderMatches();
+        }
+        return this._plainTextSearchResult.folderMatches();
+    }
     onModelAdded(model) {
-        const folderMatch = this._folderMatchesMap.findSubstr(model.uri);
+        const folderMatch = this._plainTextSearchResult.findFolderSubstr(model.uri);
         folderMatch?.bindModel(model);
     }
     async onNotebookEditorWidgetAdded(editor, resource) {
-        const folderMatch = this._folderMatchesMap.findSubstr(resource);
+        const folderMatch = this._plainTextSearchResult.findFolderSubstr(resource);
         await folderMatch?.bindNotebookEditorWidget(editor, resource);
     }
     onNotebookEditorWidgetRemoved(editor, resource) {
-        const folderMatch = this._folderMatchesMap.findSubstr(resource);
+        const folderMatch = this._plainTextSearchResult.findFolderSubstr(resource);
         folderMatch?.unbindNotebookEditorWidget(editor, resource);
     }
-    _createBaseFolderMatch(resource, id, index, query, ai) {
-        let folderMatch;
-        if (resource) {
-            folderMatch = this._register(this.instantiationService.createInstance(FolderMatchWorkspaceRoot, resource, id, index, query, this, ai));
+    add(allRaw, searchInstanceID, ai, silent = false) {
+        this._plainTextSearchResult.hidden = false;
+        this._aiTextSearchResult.hidden = false;
+        if (ai) {
+            this._aiTextSearchResult.add(allRaw, searchInstanceID, ai, silent);
         }
         else {
-            folderMatch = this._register(this.instantiationService.createInstance(FolderMatchNoRoot, id, index, query, this));
+            this._plainTextSearchResult.add(allRaw, searchInstanceID, ai, silent);
         }
-        const disposable = folderMatch.onChange((event) => this._onChange.fire(event));
-        this._register(folderMatch.onDispose(() => disposable.dispose()));
-        return folderMatch;
-    }
-    add(allRaw, searchInstanceID, ai, silent = false) {
-        const { byFolder, other } = this.groupFilesByFolder(allRaw, ai);
-        byFolder.forEach(raw => {
-            if (!raw.length) {
-                return;
-            }
-            const folderMatch = ai ? this.getAIFolderMatch(raw[0].resource) : this.getFolderMatch(raw[0].resource);
-            folderMatch?.addFileMatch(raw, silent, searchInstanceID, ai);
-        });
-        if (!ai) {
-            this._otherFilesMatch?.addFileMatch(other, silent, searchInstanceID, false);
-        }
-        this.disposePastResults();
     }
     clear() {
-        this.folderMatches().forEach((folderMatch) => folderMatch.clear(true));
-        this.folderMatches(true);
-        this.disposeMatches();
-        this._folderMatches = [];
-        this._aiFolderMatches = [];
-        this._otherFilesMatch = null;
+        this._aiTextSearchResult.clear();
+        this._plainTextSearchResult.clear();
     }
     remove(matches, ai = false) {
-        if (!Array.isArray(matches)) {
-            matches = [matches];
-        }
-        matches.forEach(m => {
-            if (m instanceof FolderMatch) {
-                m.clear();
-            }
-        });
-        const fileMatches = matches.filter(m => m instanceof FileMatch);
-        const { byFolder, other } = this.groupFilesByFolder(fileMatches, ai);
-        byFolder.forEach(matches => {
-            if (!matches.length) {
-                return;
-            }
-            this.getFolderMatch(matches[0].resource).remove(matches);
-        });
-        if (other.length) {
-            this.getFolderMatch(other[0].resource).remove(other);
+        if (ai) {
+            this._aiTextSearchResult.remove(matches, ai);
         }
+        this._plainTextSearchResult.remove(matches, ai);
     }
     replace(match) {
-        return this.getFolderMatch(match.resource).replace(match);
-    }
-    replaceAll(progress) {
-        this.replacingAll = true;
-        const promise = this.replaceService.replace(this.matches(), progress);
-        return promise.then(() => {
-            this.replacingAll = false;
-            this.clear();
-        }, () => {
-            this.replacingAll = false;
-        });
+        return this._plainTextSearchResult.replace(match);
     }
-    folderMatches(ai = false) {
-        if (ai) {
-            return this._aiFolderMatches;
+    matches(ai) {
+        if (ai === undefined) {
+            return this._plainTextSearchResult.matches().concat(this._aiTextSearchResult.matches());
         }
-        return this._otherFilesMatch ?
-            [
-                ...this._folderMatches,
-                this._otherFilesMatch
-            ] :
-            [
-                ...this._folderMatches
-            ];
-    }
-    matches(ai = false) {
-        const matches = [];
-        this.folderMatches(ai).forEach(folderMatch => {
-            matches.push(folderMatch.allDownstreamFileMatches());
-        });
-        return [].concat(...matches);
-    }
-    isEmpty(ai = false) {
-        return this.folderMatches(ai).every((folderMatch) => folderMatch.isEmpty());
+        else if (ai === true) {
+            return this._aiTextSearchResult.matches();
+        }
+        return this._plainTextSearchResult.matches();
     }
-    fileCount(ai = false) {
-        return this.folderMatches(ai).reduce((prev, match) => prev + match.recursiveFileCount(), 0);
+    isEmpty() {
+        return this._plainTextSearchResult.isEmpty() && this._aiTextSearchResult.isEmpty();
     }
-    count(ai = false) {
-        return this.matches(ai).reduce((prev, match) => prev + match.count(), 0);
+    fileCount() {
+        return this._plainTextSearchResult.fileCount() + this._aiTextSearchResult.fileCount();
     }
-    get showHighlights() {
-        return this._showHighlights;
+    count() {
+        return this._plainTextSearchResult.count() + this._aiTextSearchResult.count();
     }
-    toggleHighlights(value) {
-        if (this._showHighlights === value) {
-            return;
-        }
-        this._showHighlights = value;
-        let selectedMatch = null;
-        this.matches().forEach((fileMatch) => {
-            fileMatch.updateHighlights();
-            fileMatch.updateNotebookHighlights();
-            if (!selectedMatch) {
-                selectedMatch = fileMatch.getSelectedMatch();
-            }
-        });
-        if (this._showHighlights && selectedMatch) {
-            this._rangeHighlightDecorations.highlightRange(selectedMatch.parent().resource, selectedMatch.range());
+    setCachedSearchComplete(cachedSearchComplete, ai) {
+        if (ai) {
+            this._aiTextSearchResult.cachedSearchComplete = cachedSearchComplete;
         }
         else {
-            this._rangeHighlightDecorations.removeHighlightRange();
+            this._plainTextSearchResult.cachedSearchComplete = cachedSearchComplete;
         }
     }
-    get rangeHighlightDecorations() {
-        return this._rangeHighlightDecorations;
-    }
-    getFolderMatch(resource) {
-        const folderMatch = this._folderMatchesMap.findSubstr(resource);
-        return folderMatch ? folderMatch : this._otherFilesMatch;
-    }
-    getAIFolderMatch(resource) {
-        const folderMatch = this._aiFolderMatchesMap.findSubstr(resource);
-        return folderMatch;
+    getCachedSearchComplete(ai) {
+        if (ai) {
+            return this._aiTextSearchResult.cachedSearchComplete;
+        }
+        return this._plainTextSearchResult.cachedSearchComplete;
     }
-    set replacingAll(running) {
-        this.folderMatches().forEach((folderMatch) => {
-            folderMatch.replacingAll = running;
-        });
+    toggleHighlights(value, ai = false) {
+        if (ai) {
+            this._aiTextSearchResult.toggleHighlights(value);
+        }
+        else {
+            this._plainTextSearchResult.toggleHighlights(value);
+        }
     }
-    groupFilesByFolder(fileMatches, ai) {
-        const rawPerFolder = ( new ResourceMap());
-        const otherFileMatches = [];
-        (ai ? this._aiFolderMatches : this._folderMatches).forEach(fm => rawPerFolder.set(fm.resource, []));
-        fileMatches.forEach(rawFileMatch => {
-            const folderMatch = ai ? this.getAIFolderMatch(rawFileMatch.resource) : this.getFolderMatch(rawFileMatch.resource);
-            if (!folderMatch) {
-                return;
-            }
-            const resource = folderMatch.resource;
-            if (resource) {
-                rawPerFolder.get(resource).push(rawFileMatch);
-            }
-            else {
-                otherFileMatches.push(rawFileMatch);
-            }
-        });
-        return {
-            byFolder: rawPerFolder,
-            other: otherFileMatches
-        };
+    getRangeHighlightDecorations(ai = false) {
+        if (ai) {
+            return this._aiTextSearchResult.rangeHighlightDecorations;
+        }
+        return this._plainTextSearchResult.rangeHighlightDecorations;
     }
-    disposeMatches() {
-        this.folderMatches().forEach(folderMatch => folderMatch.dispose());
-        this.folderMatches(true).forEach(folderMatch => folderMatch.dispose());
-        this._folderMatches = [];
-        this._aiFolderMatches = [];
-        this._folderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
-        this._aiFolderMatchesMap = TernarySearchTree.forUris(key => this.uriIdentityService.extUri.ignorePathCasing(key));
-        this._rangeHighlightDecorations.removeHighlightRange();
+    replaceAll(progress) {
+        return this._plainTextSearchResult.replaceAll(progress);
     }
     async dispose() {
+        this._aiTextSearchResult?.dispose();
+        this._plainTextSearchResult?.dispose();
         this._onWillChangeModelListener?.dispose();
         this._onDidChangeModelListener?.dispose();
-        this._rangeHighlightDecorations.dispose();
-        this.disposeMatches();
         super.dispose();
-        await this.disposePastResults();
     }
 };
 SearchResult = ( __decorate([
-    ( __param(1, IReplaceService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IModelService)),
-    ( __param(4, IUriIdentityService)),
-    ( __param(5, INotebookEditorService))
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IModelService)),
+    ( __param(3, INotebookEditorService))
 ], SearchResult));
 var SearchModelLocation;
 ( (function(SearchModelLocation) {
@@ -1635,7 +1781,7 @@ var SearchModelLocation;
     SearchModelLocation[SearchModelLocation["QUICK_ACCESS"] = 1] = "QUICK_ACCESS";
 })(SearchModelLocation || (SearchModelLocation = {})));
 let SearchModel = class SearchModel extends Disposable {
-    constructor(searchService, telemetryService, configurationService, instantiationService, logService, notebookSearchService, progressService) {
+    constructor(searchService, telemetryService, configurationService, instantiationService, logService, notebookSearchService) {
         super();
         this.searchService = searchService;
         this.telemetryService = telemetryService;
@@ -1643,7 +1789,6 @@ let SearchModel = class SearchModel extends Disposable {
         this.instantiationService = instantiationService;
         this.logService = logService;
         this.notebookSearchService = notebookSearchService;
-        this.progressService = progressService;
         this._searchQuery = null;
         this._replaceActive = false;
         this._replaceString = null;
@@ -1665,6 +1810,14 @@ let SearchModel = class SearchModel extends Disposable {
         this.location = SearchModelLocation.PANEL;
         this._searchResult = this.instantiationService.createInstance(SearchResult, this);
         this._register(this._searchResult.onChange((e) => this._onSearchResultChanged.fire(e)));
+        this._aiTextResultProviderName = ( new Lazy(async () => this.searchService.getAIName()));
+    }
+    async getAITextResultProviderName() {
+        const result = await this._aiTextResultProviderName.value;
+        if (!result) {
+            throw Error('Fetching AI name when no provider present.');
+        }
+        return result;
     }
     isReplaceActive() {
         return this._replaceActive;
@@ -1695,41 +1848,35 @@ let SearchModel = class SearchModel extends Disposable {
         return this._searchResult;
     }
     async addAIResults(onProgress) {
-        if (this.searchResult.count(true)) {
-            return;
+        if (this.hasAIResults) {
+            throw Error('AI results already exist');
         }
         else {
             if (this._searchQuery) {
-                await this.aiSearch({ ...this._searchQuery, contentPattern: this._searchQuery.contentPattern.pattern, type: QueryType.aiText }, onProgress, this.currentCancelTokenSource?.token);
+                return this.aiSearch({ ...this._searchQuery, contentPattern: this._searchQuery.contentPattern.pattern, type: 3  }, onProgress);
+            }
+            else {
+                throw Error('No search query');
             }
         }
     }
-    async doAISearchWithModal(searchQuery, searchInstanceID, token, onProgress) {
-        const promise = this.searchService.aiTextSearch(searchQuery, token, async (p) => {
-            this.onSearchProgress(p, searchInstanceID, false, true);
-            onProgress?.(p);
-        });
-        return this.progressService.withProgress({
-            location: ProgressLocation.Notification,
-            type: 'syncing',
-            title: 'Searching for AI results...',
-        }, async (_) => promise);
-    }
-    aiSearch(query, onProgress, callerToken) {
+    aiSearch(query, onProgress) {
         const searchInstanceID = ( Date.now().toString());
-        const tokenSource = this.currentAICancelTokenSource = ( new CancellationTokenSource(callerToken));
+        const tokenSource = ( new CancellationTokenSource());
+        this.currentAICancelTokenSource = tokenSource;
         const start = Date.now();
-        const asyncAIResults = this.doAISearchWithModal(query, searchInstanceID, this.currentAICancelTokenSource.token, async (p) => {
+        const asyncAIResults = this.searchService.aiTextSearch(query, tokenSource.token, async (p) => {
             this.onSearchProgress(p, searchInstanceID, false, true);
             onProgress?.(p);
-        })
-            .then(value => {
+        }).finally(() => {
+            tokenSource.dispose(true);
+        }).then(value => {
             this.onSearchCompleted(value, Date.now() - start, searchInstanceID, true);
             return value;
         }, e => {
             this.onSearchError(e, Date.now() - start, true);
             throw e;
-        }).finally(() => tokenSource.dispose());
+        });
         return asyncAIResults;
     }
     doSearch(query, progressEmitter, searchQuery, searchInstanceID, onProgress, callerToken) {
@@ -1745,7 +1892,7 @@ let SearchModel = class SearchModel extends Disposable {
         };
         const tokenSource = this.currentCancelTokenSource = ( new CancellationTokenSource(callerToken));
         const notebookResult = this.notebookSearchService.notebookSearch(query, tokenSource.token, searchInstanceID, asyncGenerateOnProgress);
-        const textResult = this.searchService.textSearchSplitSyncAsync(searchQuery, this.currentCancelTokenSource.token, asyncGenerateOnProgress, notebookResult.openFilesToScan, notebookResult.allScannedFiles);
+        const textResult = this.searchService.textSearchSplitSyncAsync(searchQuery, tokenSource.token, asyncGenerateOnProgress, notebookResult.openFilesToScan, notebookResult.allScannedFiles);
         const syncResults = textResult.syncResults.results;
         syncResults.forEach(p => { if (p) {
             syncGenerateOnProgress(p);
@@ -1754,7 +1901,6 @@ let SearchModel = class SearchModel extends Disposable {
             const searchStart = Date.now();
             const allClosedEditorResults = await textResult.asyncResults;
             const resolvedNotebookResults = await notebookResult.completeData;
-            tokenSource.dispose();
             const searchLength = Date.now() - searchStart;
             const resolvedResult = {
                 results: [...allClosedEditorResults.results, ...resolvedNotebookResults.results],
@@ -1767,10 +1913,17 @@ let SearchModel = class SearchModel extends Disposable {
             return resolvedResult;
         };
         return {
-            asyncResults: getAsyncResults(),
+            asyncResults: getAsyncResults()
+                .finally(() => tokenSource.dispose(true)),
             syncResults
         };
     }
+    get hasAIResults() {
+        return !!(this.searchResult.getCachedSearchComplete(true)) || (!!this.currentAICancelTokenSource && !this.currentAICancelTokenSource.token.isCancellationRequested);
+    }
+    get hasPlainResults() {
+        return !!(this.searchResult.getCachedSearchComplete(false)) || (!!this.currentCancelTokenSource && !this.currentCancelTokenSource.token.isCancellationRequested);
+    }
     search(query, onProgress, callerToken) {
         this.cancelSearch(true);
         this._searchQuery = query;
@@ -1853,7 +2006,7 @@ let SearchModel = class SearchModel extends Disposable {
     onSearchError(e, duration, ai) {
         if (isCancellationError(e)) {
             this.onSearchCompleted((ai ? this.aiSearchCancelledForNewSearch : this.searchCancelledForNewSearch)
-                ? { exit: SearchCompletionExitCode.NewSearchStarted, results: [], messages: [] }
+                ? { exit: 1 , results: [], messages: [] }
                 : undefined, duration, '', ai);
             if (ai) {
                 this.aiSearchCancelledForNewSearch = false;
@@ -1915,8 +2068,7 @@ SearchModel = ( __decorate([
     ( __param(2, IConfigurationService)),
     ( __param(3, IInstantiationService)),
     ( __param(4, ILogService)),
-    ( __param(5, INotebookSearchService)),
-    ( __param(6, IProgressService))
+    ( __param(5, INotebookSearchService))
 ], SearchModel));
 let SearchViewModelWorkbenchService = class SearchViewModelWorkbenchService {
     constructor(instantiationService) {
@@ -2001,7 +2153,7 @@ let RangeHighlightDecorations = class RangeHighlightDecorations {
     }
     static { this._RANGE_HIGHLIGHT_DECORATION = ModelDecorationOptions.register({
         description: 'search-range-highlight',
-        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+        stickiness: 1 ,
         className: 'rangeHighlight',
         isWholeLine: true
     }); }
@@ -2067,4 +2219,4 @@ function mergeSearchResultEvents(events) {
     });
     return retEvent;
 }
-export { CellMatch, FileMatch, FolderMatch, FolderMatchNoRoot, FolderMatchWithResource, FolderMatchWorkspaceRoot, Match, MatchInNotebook, RangeHighlightDecorations, SearchModel, SearchModelLocation, SearchResult, SearchViewModelWorkbenchService, arrayContainsElementOrParent, compareNotebookPos, searchComparer, searchMatchComparer, textSearchMatchesToNotebookMatches };
+export { AI_TEXT_SEARCH_RESULT_ID, CellMatch, FileMatch, FolderMatch, FolderMatchNoRoot, FolderMatchWithResource, FolderMatchWorkspaceRoot, Match, MatchInNotebook, PLAIN_TEXT_SEARCH__RESULT_ID, RangeHighlightDecorations, ReplaceableTextSearchResult, SearchModel, SearchModelLocation, SearchResult, SearchViewModelWorkbenchService, TextSearchResult, arrayContainsElementOrParent, compareNotebookPos, searchComparer, searchMatchComparer, textSearchMatchesToNotebookMatches };