@codingame/monaco-vscode-api 1.81.8-next.2 → 1.82.0-next.0

package/vscode/src/vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess.js

@@ -0,0 +1,232 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { basenameOrAuthority, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { getSelectionKeyboardEvent } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { PickerQuickAccessProvider } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { DefaultQuickAccessFilterValue } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IViewsService } from '../../../../common/views.js';
+import { searchDetailsIcon, searchOpenInFileIcon } from '../searchIcons.js';
+import { SearchModel, searchComparer, MatchInNotebook } from '../searchModel.js';
+import { getEditorSelectionFromMatch } from '../searchView.js';
+import { getOutOfWorkspaceEditorResources } from '../../common/search.js';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../../../../services/editor/common/editorService.js';
+import { QueryBuilder } from '../../../../services/search/common/queryBuilder.js';
+import { VIEW_ID } from '../../../../services/search/common/search.js';
+const TEXT_SEARCH_QUICK_ACCESS_PREFIX = '% ';
+const DEFAULT_TEXT_QUERY_BUILDER_OPTIONS = {
+    _reason: 'quickAccessSearch',
+    disregardIgnoreFiles: false,
+    disregardExcludeSettings: false,
+    onlyOpenEditors: false,
+    expandPatterns: true
+};
+const MAX_FILES_SHOWN = 30;
+const MAX_RESULTS_PER_FILE = 10;
+let TextSearchQuickAccess = class TextSearchQuickAccess extends PickerQuickAccessProvider {
+    _getTextQueryBuilderOptions(charsPerLine) {
+        return {
+            ...DEFAULT_TEXT_QUERY_BUILDER_OPTIONS,
+            ...{
+                extraFileResources: this._instantiationService.invokeFunction(getOutOfWorkspaceEditorResources),
+                maxResults: this.configuration.maxResults ?? undefined,
+                isSmartCase: this.configuration.smartCase,
+            },
+            previewOptions: {
+                matchLines: 1,
+                charsPerLine
+            }
+        };
+    }
+    constructor(_instantiationService, _contextService, _editorService, _labelService, _viewsService, _configurationService) {
+        super(TEXT_SEARCH_QUICK_ACCESS_PREFIX, { canAcceptInBackground: true });
+        this._instantiationService = _instantiationService;
+        this._contextService = _contextService;
+        this._editorService = _editorService;
+        this._labelService = _labelService;
+        this._viewsService = _viewsService;
+        this._configurationService = _configurationService;
+        this.queryBuilder = this._instantiationService.createInstance(QueryBuilder);
+        this.searchModel = this._instantiationService.createInstance(SearchModel);
+    }
+    dispose() {
+        this.searchModel.dispose();
+        super.dispose();
+    }
+    provide(picker, token, runOptions) {
+        const disposables = ( new DisposableStore());
+        disposables.add(super.provide(picker, token, runOptions));
+        disposables.add(picker.onDidHide(() => this.searchModel.searchResult.toggleHighlights(false)));
+        disposables.add(picker.onDidAccept(() => this.searchModel.searchResult.toggleHighlights(false)));
+        return disposables;
+    }
+    get configuration() {
+        const editorConfig = this._configurationService.getValue().workbench?.editor;
+        const searchConfig = this._configurationService.getValue().search;
+        return {
+            openEditorPinned: !editorConfig?.enablePreviewFromQuickOpen || !editorConfig?.enablePreview,
+            preserveInput: searchConfig.experimental.quickAccess.preserveInput,
+            maxResults: searchConfig.maxResults,
+            smartCase: searchConfig.smartCase,
+        };
+    }
+    get defaultFilterValue() {
+        if (this.configuration.preserveInput) {
+            return DefaultQuickAccessFilterValue.LAST;
+        }
+        return undefined;
+    }
+    doSearch(contentPattern, token) {
+        if (contentPattern === '') {
+            return undefined;
+        }
+        const folderResources = this._contextService.getWorkspace().folders;
+        const content = {
+            pattern: contentPattern,
+        };
+        const charsPerLine = content.isRegExp ? 10000 : 1000;
+        const query = this.queryBuilder.text(content, ( folderResources.map(folder => folder.uri)), this._getTextQueryBuilderOptions(charsPerLine));
+        const result = this.searchModel.search(query, undefined, token);
+        const getAsyncResults = async () => {
+            await result.asyncResults;
+            return this.searchModel.searchResult.matches().filter(e => result.syncResults.indexOf(e) === -1);
+        };
+        return {
+            syncResults: this.searchModel.searchResult.matches(),
+            asyncResults: getAsyncResults()
+        };
+    }
+    moveToSearchViewlet(model, currentElem) {
+        this._viewsService.openView(VIEW_ID, false);
+        const viewlet = this._viewsService.getActiveViewWithId(VIEW_ID);
+        viewlet.importSearchResult(model);
+        const viewer = viewlet?.getControl();
+        viewer.setFocus([currentElem], getSelectionKeyboardEvent());
+        viewer.setSelection([currentElem], getSelectionKeyboardEvent());
+        viewer.reveal(currentElem);
+    }
+    _getPicksFromMatches(matches, limit) {
+        matches = matches.sort(searchComparer);
+        const files = matches.length > limit ? matches.slice(0, limit) : matches;
+        const picks = [];
+        for (let fileIndex = 0; fileIndex < matches.length; fileIndex++) {
+            if (fileIndex === limit) {
+                picks.push({
+                    type: 'separator',
+                });
+                picks.push({
+                    label: ( localize('QuickSearchSeeMoreFiles', "See More Files")),
+                    iconClass: ThemeIcon.asClassName(searchDetailsIcon),
+                    accept: async () => {
+                        this.moveToSearchViewlet(this.searchModel, matches[limit]);
+                    }
+                });
+                break;
+            }
+            const fileMatch = files[fileIndex];
+            const label = basenameOrAuthority(fileMatch.resource);
+            const description = this._labelService.getUriLabel(dirname(fileMatch.resource), { relative: true });
+            picks.push({
+                label,
+                type: 'separator',
+                tooltip: description,
+                buttons: [{
+                        iconClass: ThemeIcon.asClassName(searchOpenInFileIcon),
+                        tooltip: ( localize('QuickSearchOpenInFile', "Open File"))
+                    }],
+            });
+            const results = fileMatch.matches() ?? [];
+            for (let matchIndex = 0; matchIndex < results.length; matchIndex++) {
+                const element = results[matchIndex];
+                if (matchIndex === MAX_RESULTS_PER_FILE) {
+                    picks.push({
+                        label: ( localize('QuickSearchMore', "More")),
+                        iconClass: ThemeIcon.asClassName(searchDetailsIcon),
+                        accept: async () => {
+                            this.moveToSearchViewlet(this.searchModel, element);
+                        }
+                    });
+                    break;
+                }
+                const preview = element.preview();
+                const previewText = (preview.before + preview.inside + preview.after).trim().substring(0, 999);
+                const match = [{
+                        start: preview.before.length,
+                        end: preview.before.length + preview.inside.length
+                    }];
+                picks.push({
+                    label: `${previewText}`,
+                    highlights: {
+                        label: match
+                    },
+                    ariaLabel: `Match at location ${element.range().startLineNumber}:${element.range().startColumn} - ${previewText}`,
+                    accept: async (keyMods, event) => {
+                        await this.handleAccept(fileMatch, {
+                            keyMods,
+                            selection: getEditorSelectionFromMatch(element, this.searchModel),
+                            preserveFocus: event.inBackground,
+                            forcePinned: event.inBackground,
+                            indexedCellOptions: element instanceof MatchInNotebook ? { index: element.cellIndex, selection: element.range() } : undefined
+                        });
+                    }
+                });
+            }
+        }
+        return picks;
+    }
+    async handleAccept(fileMatch, options) {
+        const editorOptions = {
+            preserveFocus: options.preserveFocus,
+            pinned: options.keyMods?.ctrlCmd || options.forcePinned || this.configuration.openEditorPinned,
+            selection: options.selection
+        };
+        const targetGroup = options.keyMods?.alt || (this.configuration.openEditorPinned && options.keyMods?.ctrlCmd) || options.forceOpenSideBySide ? SIDE_GROUP : ACTIVE_GROUP;
+        await this._editorService.openEditor({
+            resource: fileMatch.resource,
+            options: editorOptions
+        }, targetGroup);
+    }
+    _getPicks(contentPattern, disposables, token) {
+        if (contentPattern === '') {
+            this.searchModel.searchResult.clear();
+            return [];
+        }
+        const allMatches = this.doSearch(contentPattern, token);
+        if (!allMatches) {
+            return null;
+        }
+        const matches = allMatches.syncResults;
+        const syncResult = this._getPicksFromMatches(matches, MAX_FILES_SHOWN);
+        if (syncResult.length > 0) {
+            this.searchModel.searchResult.toggleHighlights(true);
+        }
+        if (matches.length >= MAX_FILES_SHOWN) {
+            return syncResult;
+        }
+        return {
+            picks: syncResult,
+            additionalPicks: allMatches.asyncResults
+                .then(asyncResults => this._getPicksFromMatches(asyncResults, MAX_FILES_SHOWN - matches.length))
+                .then(picks => {
+                if (picks.length > 0) {
+                    this.searchModel.searchResult.toggleHighlights(true);
+                }
+                return picks;
+            })
+        };
+    }
+};
+TextSearchQuickAccess = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IViewsService)),
+    ( __param(5, IConfigurationService))
+], TextSearchQuickAccess));
+export { TEXT_SEARCH_QUICK_ACCESS_PREFIX, TextSearchQuickAccess };

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

@@ -6,7 +6,7 @@ import { IReplaceService } from './replace.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { Match, MatchInNotebook, FileMatch, ISearchWorkbenchService } from './searchModel.js';
+import { Match, MatchInNotebook, FileMatch, ISearchViewModelWorkbenchService } from './searchModel.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { createTextBufferFactoryFromSnapshot } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
@@ -20,6 +20,7 @@ import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
 import { SaveSourceRegistry } from '../../../common/editor.js';
 import { CellUri } from '../../notebook/common/notebookCommon.js';
 import { INotebookEditorModelResolverService } from '../../notebook/common/notebookEditorModelResolverService.js';
+var ReplaceService_1;
 const REPLACE_PREVIEW = 'replacePreview';
 const toReplaceResource = (fileResource) => {
     return fileResource.with({ scheme: network.Schemas.internal, fragment: REPLACE_PREVIEW, query: JSON.stringify({ scheme: fileResource.scheme }) });
@@ -78,9 +79,10 @@ ReplacePreviewModel = ( __decorate([
     ( __param(1, ILanguageService)),
     ( __param(2, ITextModelService)),
     ( __param(3, IReplaceService)),
-    ( __param(4, ISearchWorkbenchService))
+    ( __param(4, ISearchViewModelWorkbenchService))
 ], ReplacePreviewModel));
 let ReplaceService = class ReplaceService {
+    static { ReplaceService_1 = this; }
     static { this.REPLACE_SAVE_SOURCE = SaveSourceRegistry.registerSource('searchReplace.source', ( nls.localize('searchReplace.source', "Search and Replace"))); }
     constructor(textFileService, editorService, textModelResolverService, bulkEditorService, labelService, notebookEditorModelResolverService) {
         this.textFileService = textFileService;
@@ -100,7 +102,7 @@ let ReplaceService = class ReplaceService {
                     let ref;
                     try {
                         ref = await this.notebookEditorModelResolverService.resolve(notebookResource);
-                        await ref.object.save({ source: ReplaceService.REPLACE_SAVE_SOURCE });
+                        await ref.object.save({ source: ReplaceService_1.REPLACE_SAVE_SOURCE });
                     }
                     finally {
                         ref?.dispose();
@@ -109,7 +111,7 @@ let ReplaceService = class ReplaceService {
                 return;
             }
             else {
-                return this.textFileService.files.get(e.resource)?.save({ source: ReplaceService.REPLACE_SAVE_SOURCE });
+                return this.textFileService.files.get(e.resource)?.save({ source: ReplaceService_1.REPLACE_SAVE_SOURCE });
             }
         }));
         return Promises.settled(rawTextPromises);
@@ -211,7 +213,7 @@ let ReplaceService = class ReplaceService {
         ));
     }
 };
-ReplaceService = ( __decorate([
+ReplaceService = ReplaceService_1 = ( __decorate([
     ( __param(0, ITextFileService)),
     ( __param(1, IEditorService)),
     ( __param(2, ITextModelService)),

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

@@ -21,13 +21,15 @@ import { VIEWLET_ID, SEARCH_EXCLUDE_CONFIG, VIEW_ID } from '../../../services/se
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
 import { getWorkspaceSymbols } from '../common/search.js';
-import { ShowAllSymbolsActionId } from '../common/constants.js';
+import { ShowAllSymbolsActionId, QuickTextSearchActionId } from '../common/constants.js';
 import './searchActionsCopy.js';
 import './searchActionsFind.js';
 import './searchActionsNav.js';
 import './searchActionsRemoveReplace.js';
 import './searchActionsSymbol.js';
 import './searchActionsTopBar.js';
+import './searchActionsTextQuickAccess.js';
+import { TextSearchQuickAccess, TEXT_SEARCH_QUICK_ACCESS_PREFIX } from './quickTextSearch/textSearchQuickAccess.js';
 registerContributions();
 registerContributions$1();
 registerContributions$2();
@@ -72,7 +74,11 @@ quickAccessRegistry.registerQuickAccessProvider({
         GotoSymbolQuickAccessProvider.PREFIX
     )),
     contextKey: defaultQuickAccessContextKeyValue,
-    helpEntries: [{ description: ( nls.localize('anythingQuickAccess', "Go to File")), commandId: 'workbench.action.quickOpen' }]
+    helpEntries: [{
+            description: ( nls.localize('anythingQuickAccess', "Go to File")),
+            commandId: 'workbench.action.quickOpen',
+            commandCenterOrder: 10
+        }]
 });
 quickAccessRegistry.registerQuickAccessProvider({
     ctor: SymbolsQuickAccessProvider,
@@ -81,6 +87,22 @@ quickAccessRegistry.registerQuickAccessProvider({
     contextKey: 'inWorkspaceSymbolsPicker',
     helpEntries: [{ description: ( nls.localize('symbolsQuickAccess', "Go to Symbol in Workspace")), commandId: ShowAllSymbolsActionId }]
 });
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: TextSearchQuickAccess,
+    prefix: TEXT_SEARCH_QUICK_ACCESS_PREFIX,
+    contextKey: 'inTextSearchPicker',
+    placeholder: ( nls.localize(
+        'textSearchPickerPlaceholder',
+        "Search for text in your workspace files (experimental)."
+    )),
+    helpEntries: [
+        {
+            description: ( nls.localize('textSearchPickerHelp', "Search for Text (Experimental)")),
+            commandId: QuickTextSearchActionId,
+            commandCenterOrder: 65,
+        }
+    ]
+});
 const configurationRegistry = ( Registry.as(Extensions$2.Configuration));
 configurationRegistry.registerConfiguration({
     id: 'search',
@@ -472,7 +494,15 @@ configurationRegistry.registerConfiguration({
                 "Show notebook editor rich content results for closed notebooks. Please refresh your search results after changing this setting."
             )),
             default: false
-        }
+        },
+        'search.experimental.quickAccess.preserveInput': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'search.experimental.quickAccess.preserveInput',
+                "Controls whether the last typed input to Quick Search should be restored when opening it the next time."
+            )),
+            'default': false
+        },
     }
 });
 CommandsRegistry.registerCommand('_executeWorkspaceSymbolProvider', async function (accessor, ...args) {

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

@@ -18,7 +18,6 @@ import { VIEWLET_ID, FilesExplorerFocusCondition, ExplorerFolderContext, Explore
 import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { category, getSearchView, openSearchView, getElementsToOperateOn } from './searchActionsBase.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
 import { IHistoryService } from '../../../services/history/common/history.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
@@ -312,7 +311,7 @@ async function findInFilesCommand(accessor, _args = {}) {
         const workspaceContextService = accessor.get(IWorkspaceContextService);
         const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot();
         const filteredActiveWorkspaceRootUri = activeWorkspaceRootUri?.scheme === Schemas.file || activeWorkspaceRootUri?.scheme === Schemas.vscodeRemote ? activeWorkspaceRootUri : undefined;
-        const lastActiveWorkspaceRoot = filteredActiveWorkspaceRootUri ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(filteredActiveWorkspaceRootUri)) : undefined;
+        const lastActiveWorkspaceRoot = filteredActiveWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(filteredActiveWorkspaceRootUri) ?? undefined : undefined;
         for (const entry of Object.entries(_args)) {
             const name = entry[0];
             const value = entry[1];

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

@@ -29,14 +29,14 @@ registerAction2(class ToggleQueryDetailsAction extends Action2 {
             },
         });
     }
-    run(accessor) {
+    run(accessor, ...args) {
         const contextService = accessor.get(IContextKeyService).getContext(document.activeElement);
         if (contextService.getValue(InSearchEditor.serialize())) {
-            accessor.get(IEditorService).activeEditorPane.toggleQueryDetails();
+            accessor.get(IEditorService).activeEditorPane.toggleQueryDetails(args[0]?.show);
         }
         else if (contextService.getValue(SearchViewFocusedKey.serialize())) {
             const searchView = getSearchView(accessor.get(IViewsService));
-            assertIsDefined(searchView).toggleQueryDetails();
+            assertIsDefined(searchView).toggleQueryDetails(undefined, args[0]?.show);
         }
     }
 });

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

@@ -0,0 +1,23 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { QuickTextSearchActionId } from '../common/constants.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { category } from './searchActionsBase.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { TEXT_SEARCH_QUICK_ACCESS_PREFIX } from './quickTextSearch/textSearchQuickAccess.js';
+registerAction2(class TextSearchQuickAccessAction extends Action2 {
+    constructor() {
+        super({
+            id: QuickTextSearchActionId,
+            title: {
+                value: ( nls.localize('quickTextSearch', "Quick Text Search (Experimental)")),
+                original: 'Quick Text Search (Experimental)'
+            },
+            category,
+            f1: true
+        });
+    }
+    async run(accessor, match) {
+        const quickInputService = accessor.get(IQuickInputService);
+        quickInputService.quickAccess.show(TEXT_SEARCH_QUICK_ACCESS_PREFIX);
+    }
+});

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

@@ -32,4 +32,8 @@ const searchClearIcon = registerIcon('search-clear-results', Codicon.clearAll, (
 const searchStopIcon = registerIcon('search-stop', Codicon.searchStop, ( localize('searchStopIcon', 'Icon for stop in the search view.')));
 const searchViewIcon = registerIcon('search-view-icon', Codicon.search, ( localize('searchViewIcon', 'View icon of the search view.')));
 const searchNewEditorIcon = registerIcon('search-new-editor', Codicon.newFile, ( localize('searchNewEditorIcon', 'Icon for the action to open a new search editor.')));
-export { searchClearIcon, searchCollapseAllIcon, searchDetailsIcon, searchExpandAllIcon, searchHideReplaceIcon, searchNewEditorIcon, searchRefreshIcon, searchRemoveIcon, searchReplaceAllIcon, searchReplaceIcon, searchShowAsList, searchShowAsTree, searchShowContextIcon, searchShowReplaceIcon, searchStopIcon, searchViewIcon };
+const searchOpenInFileIcon = registerIcon('search-open-in-file', Codicon.goToFile, ( localize(
+ 'searchOpenInFile',
+ 'Icon for the action to go to the file of the current search result.'
+)));
+export { searchClearIcon, searchCollapseAllIcon, searchDetailsIcon, searchExpandAllIcon, searchHideReplaceIcon, searchNewEditorIcon, searchOpenInFileIcon, searchRefreshIcon, searchRemoveIcon, searchReplaceAllIcon, searchReplaceIcon, searchShowAsList, searchShowAsTree, searchShowContextIcon, searchShowReplaceIcon, searchStopIcon, searchViewIcon };