@codingame/monaco-vscode-api 1.79.2 → 1.79.3-next.2

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

@@ -0,0 +1,355 @@
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IListService } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IViewsService } from '../../../common/views.js';
+import { RestrictSearchToFolderId, SearchViewVisibleKey, ResourceFolderFocusKey, ExcludeFolderFromSearchId, RevealInSideBarForSearchResults, FileFocusKey, HasSearchResults, FindInFilesActionId, FindInFolderId, FindInWorkspaceId } from '../common/constants.js';
+import { OpenEditorCommandId } from '../../searchEditor/browser/constants.js';
+import { FileMatch, Match } from './searchModel.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { resolveResourcesForSearchIncludes } from '../../../services/search/common/queryBuilder.js';
+import { IExplorerService, getMultiSelectedResources } from '../../files/browser/files.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { VIEWLET_ID, FilesExplorerFocusCondition, ExplorerFolderContext, ExplorerRootContext } from '../../files/common/files.js';
+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';
+registerAction2(class RestrictSearchToFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: RestrictSearchToFolderId,
+            title: {
+                value: ( nls.localize('restrictResultsToFolder', "Restrict Search to Folder")),
+                original: 'Restrict Search to Folder'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchViewVisibleKey, ResourceFolderFocusKey)),
+                primary: 1024  | 512  | 36 ,
+            },
+            menu: [
+                {
+                    id: MenuId.SearchContext,
+                    group: 'search',
+                    order: 3,
+                    when: ( ContextKeyExpr.and(ResourceFolderFocusKey))
+                }
+            ]
+        });
+    }
+    async run(accessor, folderMatch) {
+        await searchWithFolderCommand(accessor, false, true, undefined, folderMatch);
+    }
+});
+registerAction2(class ExcludeFolderFromSearchAction extends Action2 {
+    constructor() {
+        super({
+            id: ExcludeFolderFromSearchId,
+            title: {
+                value: ( nls.localize('excludeFolderFromSearch', "Exclude Folder from Search")),
+                original: 'Exclude Folder from Search'
+            },
+            category,
+            menu: [
+                {
+                    id: MenuId.SearchContext,
+                    group: 'search',
+                    order: 4,
+                    when: ( ContextKeyExpr.and(ResourceFolderFocusKey))
+                }
+            ]
+        });
+    }
+    async run(accessor, folderMatch) {
+        await searchWithFolderCommand(accessor, false, false, undefined, folderMatch);
+    }
+});
+registerAction2(class RevealInSideBarForSearchResultsAction extends Action2 {
+    constructor() {
+        super({
+            id: RevealInSideBarForSearchResults,
+            title: {
+                value: ( nls.localize('revealInSideBar', "Reveal in Explorer View")),
+                original: 'Reveal in Explorer View'
+            },
+            category,
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: ( ContextKeyExpr.and(FileFocusKey, HasSearchResults)),
+                    group: 'search_3',
+                    order: 1
+                }]
+        });
+    }
+    async run(accessor, args) {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const explorerService = accessor.get(IExplorerService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (!searchView) {
+            return;
+        }
+        let fileMatch;
+        if (!(args instanceof FileMatch)) {
+            args = searchView.getControl().getFocus()[0];
+        }
+        if (args instanceof FileMatch) {
+            fileMatch = args;
+        }
+        else {
+            return;
+        }
+        paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , false).then((viewlet) => {
+            if (!viewlet) {
+                return;
+            }
+            const explorerViewContainer = viewlet.getViewPaneContainer();
+            const uri = fileMatch.resource;
+            if (uri && contextService.isInsideWorkspace(uri)) {
+                const explorerView = explorerViewContainer.getExplorerView();
+                explorerView.setExpanded(true);
+                explorerService.select(uri, true).then(() => explorerView.focus(), onUnexpectedError);
+            }
+        });
+    }
+});
+registerAction2(class FindInFilesAction extends Action2 {
+    constructor() {
+        super({
+            id: FindInFilesActionId,
+            title: {
+                value: ( nls.localize('findInFiles', "Find in Files")),
+                mnemonicTitle: ( nls.localize(
+                    { key: 'miFindInFiles', comment: ['&& denotes a mnemonic'] },
+                    "Find &&in Files"
+                )),
+                original: 'Find in Files'
+            },
+            description: {
+                description: ( nls.localize('findInFiles.description', "Open a workspace search")),
+                args: [
+                    {
+                        name: ( nls.localize('findInFiles.args', "A set of options for the search")),
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                query: { 'type': 'string' },
+                                replace: { 'type': 'string' },
+                                preserveCase: { 'type': 'boolean' },
+                                triggerSearch: { 'type': 'boolean' },
+                                filesToInclude: { 'type': 'string' },
+                                filesToExclude: { 'type': 'string' },
+                                isRegex: { 'type': 'boolean' },
+                                isCaseSensitive: { 'type': 'boolean' },
+                                matchWholeWord: { 'type': 'boolean' },
+                                useExcludeSettingsAndIgnoreFiles: { 'type': 'boolean' },
+                                onlyOpenEditors: { 'type': 'boolean' },
+                            }
+                        }
+                    },
+                ]
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 36 ,
+            },
+            menu: [{
+                    id: MenuId.MenubarEditMenu,
+                    group: '4_find_global',
+                    order: 1,
+                }],
+            f1: true
+        });
+    }
+    async run(accessor, args = {}) {
+        findInFilesCommand(accessor, args);
+    }
+});
+registerAction2(class FindInFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: FindInFolderId,
+            title: {
+                value: ( nls.localize('findInFolder', "Find in Folder...")),
+                original: 'Find in Folder...'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ExplorerFolderContext)),
+                primary: 1024  | 512  | 36 ,
+            },
+            menu: [
+                {
+                    id: MenuId.ExplorerContext,
+                    group: '4_search',
+                    order: 10,
+                    when: ( ContextKeyExpr.and(ExplorerFolderContext))
+                }
+            ]
+        });
+    }
+    async run(accessor, resource) {
+        await searchWithFolderCommand(accessor, true, true, resource);
+    }
+});
+registerAction2(class FindInWorkspaceAction extends Action2 {
+    constructor() {
+        super({
+            id: FindInWorkspaceId,
+            title: {
+                value: ( nls.localize('findInWorkspace', "Find in Workspace...")),
+                original: 'Find in Workspace...'
+            },
+            category,
+            menu: [
+                {
+                    id: MenuId.ExplorerContext,
+                    group: '4_search',
+                    order: 10,
+                    when: ( ContextKeyExpr.and(ExplorerRootContext, ( ExplorerFolderContext.toNegated())))
+                }
+            ]
+        });
+    }
+    async run(accessor) {
+        const searchConfig = accessor.get(IConfigurationService).getValue().search;
+        const mode = searchConfig.mode;
+        if (mode === 'view') {
+            const searchView = await openSearchView(accessor.get(IViewsService), true);
+            searchView?.searchInFolders();
+        }
+        else {
+            return accessor.get(ICommandService).executeCommand(OpenEditorCommandId, {
+                location: mode === 'newEditor' ? 'new' : 'reuse',
+                filesToInclude: '',
+            });
+        }
+    }
+});
+async function searchWithFolderCommand(accessor, isFromExplorer, isIncludes, resource, folderMatch) {
+    const listService = accessor.get(IListService);
+    const fileService = accessor.get(IFileService);
+    const viewsService = accessor.get(IViewsService);
+    const contextService = accessor.get(IWorkspaceContextService);
+    const commandService = accessor.get(ICommandService);
+    const searchConfig = accessor.get(IConfigurationService).getValue().search;
+    const mode = searchConfig.mode;
+    let resources;
+    if (isFromExplorer) {
+        resources = getMultiSelectedResources(resource, listService, accessor.get(IEditorService), accessor.get(IExplorerService));
+    }
+    else {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (!searchView) {
+            return;
+        }
+        resources = getMultiSelectedSearchResources(searchView.getControl(), folderMatch, searchConfig);
+    }
+    const resolvedResources = fileService.resolveAll(( resources.map(resource => ({ resource })))).then(results => {
+        const folders = [];
+        results.forEach(result => {
+            if (result.success && result.stat) {
+                folders.push(result.stat.isDirectory ? result.stat.resource : dirname(result.stat.resource));
+            }
+        });
+        return resolveResourcesForSearchIncludes(folders, contextService);
+    });
+    if (mode === 'view') {
+        const searchView = await openSearchView(viewsService, true);
+        if (resources && resources.length && searchView) {
+            if (isIncludes) {
+                searchView.searchInFolders(await resolvedResources);
+            }
+            else {
+                searchView.searchOutsideOfFolders(await resolvedResources);
+            }
+        }
+        return undefined;
+    }
+    else {
+        if (isIncludes) {
+            return commandService.executeCommand(OpenEditorCommandId, {
+                filesToInclude: (await resolvedResources).join(', '),
+                showIncludesExcludes: true,
+                location: mode === 'newEditor' ? 'new' : 'reuse',
+            });
+        }
+        else {
+            return commandService.executeCommand(OpenEditorCommandId, {
+                filesToExclude: (await resolvedResources).join(', '),
+                showIncludesExcludes: true,
+                location: mode === 'newEditor' ? 'new' : 'reuse',
+            });
+        }
+    }
+}
+function getMultiSelectedSearchResources(viewer, currElement, sortConfig) {
+    return ( getElementsToOperateOn(viewer, currElement, sortConfig)
+        .map(
+        (renderableMatch) => ((renderableMatch instanceof Match) ? null : renderableMatch.resource)
+    ))
+        .filter((renderableMatch) => (renderableMatch !== null));
+}
+async function findInFilesCommand(accessor, _args = {}) {
+    const searchConfig = accessor.get(IConfigurationService).getValue().search;
+    const viewsService = accessor.get(IViewsService);
+    const commandService = accessor.get(ICommandService);
+    const args = {};
+    if (( Object.keys(_args)).length !== 0) {
+        const configurationResolverService = accessor.get(IConfigurationResolverService);
+        const historyService = accessor.get(IHistoryService);
+        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;
+        for (const entry of Object.entries(_args)) {
+            const name = entry[0];
+            const value = entry[1];
+            if (value !== undefined) {
+                args[name] = (typeof value === 'string') ? await configurationResolverService.resolveAsync(lastActiveWorkspaceRoot, value) : value;
+            }
+        }
+    }
+    const mode = searchConfig.mode;
+    if (mode === 'view') {
+        openSearchView(viewsService, false).then(openedView => {
+            if (openedView) {
+                const searchAndReplaceWidget = openedView.searchAndReplaceWidget;
+                searchAndReplaceWidget.toggleReplace(typeof args.replace === 'string');
+                let updatedText = false;
+                if (typeof args.query !== 'string') {
+                    updatedText = openedView.updateTextFromFindWidgetOrSelection({ allowUnselectedWord: typeof args.replace !== 'string' });
+                }
+                openedView.setSearchParameters(args);
+                openedView.searchAndReplaceWidget.focus(undefined, updatedText, updatedText);
+            }
+        });
+    }
+    else {
+        const convertArgs = (args) => ({
+            location: mode === 'newEditor' ? 'new' : 'reuse',
+            query: args.query,
+            filesToInclude: args.filesToInclude,
+            filesToExclude: args.filesToExclude,
+            matchWholeWord: args.matchWholeWord,
+            isCaseSensitive: args.isCaseSensitive,
+            isRegexp: args.isRegex,
+            useExcludeSettingsAndIgnoreFiles: args.useExcludeSettingsAndIgnoreFiles,
+            onlyOpenEditors: args.onlyOpenEditors,
+            showIncludesExcludes: !!(args.filesToExclude || args.filesToExclude || !args.useExcludeSettingsAndIgnoreFiles),
+        });
+        commandService.executeCommand(OpenEditorCommandId, convertArgs(args));
+    }
+}
+export { findInFilesCommand };