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

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

@@ -0,0 +1,461 @@
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IViewsService } from '../../../common/views.js';
+import { ToggleQueryDetailsActionId, SearchViewFocusedKey, CloseReplaceWidgetActionId, SearchViewVisibleKey, ReplaceInputBoxFocusedKey, ToggleCaseSensitiveCommandId, FileMatchOrFolderMatchFocusKey, ToggleWholeWordCommandId, ToggleRegexCommandId, TogglePreserveCaseId, OpenMatch, FileMatchOrMatchFocusKey, OpenMatchToSide, AddCursorsAtSearchResults, FocusNextInputActionId, InputBoxFocusedKey, FocusPreviousInputActionId, SearchInputBoxFocusedKey, FocusSearchFromResults, FirstMatchFocusKey, FocusSearchListCommandID, FocusNextSearchResultActionId, HasSearchResults, FocusPreviousSearchResultActionId, ReplaceInFilesActionId, ToggleSearchOnTypeActionId } from '../common/constants.js';
+import { InSearchEditor } from '../../searchEditor/browser/constants.js';
+import { FolderMatch } from './searchModel.js';
+import { SearchEditorInput } from '../../searchEditor/browser/searchEditorInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ToggleCaseSensitiveKeybinding, ToggleWholeWordKeybinding, ToggleRegexKeybinding, TogglePreserveCaseKeybinding } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findModel.js';
+import { category, getSearchView, openSearchView } from './searchActionsBase.js';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+var _a;
+registerAction2(class ToggleQueryDetailsAction extends Action2 {
+    constructor() {
+        super({
+            id: ToggleQueryDetailsActionId,
+            title: {
+                value: ( nls.localize('ToggleQueryDetailsAction.label', "Toggle Query Details")),
+                original: 'Toggle Query Details'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.or(SearchViewFocusedKey, InSearchEditor)),
+                primary: 2048  | 1024  | 40 ,
+            },
+        });
+    }
+    run(accessor) {
+        const contextService = accessor.get(IContextKeyService).getContext(document.activeElement);
+        if (contextService.getValue(InSearchEditor.serialize())) {
+            accessor.get(IEditorService).activeEditorPane.toggleQueryDetails();
+        }
+        else if (contextService.getValue(SearchViewFocusedKey.serialize())) {
+            const searchView = getSearchView(accessor.get(IViewsService));
+            assertIsDefined(searchView).toggleQueryDetails();
+        }
+    }
+});
+registerAction2(class CloseReplaceAction extends Action2 {
+    constructor() {
+        super({
+            id: CloseReplaceWidgetActionId,
+            title: {
+                value: ( nls.localize('CloseReplaceWidget.label', "Close Replace Widget")),
+                original: 'Close Replace Widget'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchViewVisibleKey, ReplaceInputBoxFocusedKey)),
+                primary: 9 ,
+            },
+        });
+    }
+    run(accessor) {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (searchView) {
+            searchView.searchAndReplaceWidget.toggleReplace(false);
+            searchView.searchAndReplaceWidget.focus();
+        }
+        return Promise.resolve(null);
+    }
+});
+registerAction2(class ToggleCaseSensitiveCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: ToggleCaseSensitiveCommandId,
+            title: {
+                value: ( nls.localize('ToggleCaseSensitiveCommandId.label', "Toggle Case Sensitive")),
+                original: 'Toggle Case Sensitive'
+            },
+            category,
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: isMacintosh ? ( ContextKeyExpr.and(SearchViewFocusedKey, ( FileMatchOrFolderMatchFocusKey.toNegated()))) : SearchViewFocusedKey,
+            }, ToggleCaseSensitiveKeybinding)
+        });
+    }
+    async run(accessor) {
+        toggleCaseSensitiveCommand(accessor);
+    }
+});
+registerAction2(class ToggleWholeWordCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: ToggleWholeWordCommandId,
+            title: {
+                value: ( nls.localize('ToggleWholeWordCommandId.label', 'Toggle Whole Word')),
+                original: 'Toggle Whole Word'
+            },
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchViewFocusedKey,
+            }, ToggleWholeWordKeybinding),
+            category,
+        });
+    }
+    async run(accessor) {
+        return toggleWholeWordCommand(accessor);
+    }
+});
+registerAction2(class ToggleRegexCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: ToggleRegexCommandId,
+            title: {
+                value: ( nls.localize('ToggleRegexCommandId.label', 'Toggle Regex')),
+                original: 'Toggle Regex'
+            },
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchViewFocusedKey,
+            }, ToggleRegexKeybinding),
+            category,
+        });
+    }
+    async run(accessor) {
+        return toggleRegexCommand(accessor);
+    }
+});
+registerAction2(class TogglePreserveCaseAction extends Action2 {
+    constructor() {
+        super({
+            id: TogglePreserveCaseId,
+            title: {
+                value: ( nls.localize('TogglePreserveCaseId.label', 'Toggle Preserve Case')),
+                original: 'Toggle Preserve Case'
+            },
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchViewFocusedKey,
+            }, TogglePreserveCaseKeybinding),
+            category,
+        });
+    }
+    async run(accessor) {
+        return togglePreserveCaseCommand(accessor);
+    }
+});
+registerAction2(class OpenMatchAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenMatch,
+            title: {
+                value: ( nls.localize('OpenMatch.label', "Open Match")),
+                original: 'Open Match'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchViewVisibleKey, FileMatchOrMatchFocusKey)),
+                primary: 3 ,
+                mac: {
+                    primary: 3 ,
+                    secondary: [2048  | 18 ]
+                },
+            },
+        });
+    }
+    run(accessor) {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (searchView) {
+            const tree = searchView.getControl();
+            const viewer = searchView.getControl();
+            const focus = tree.getFocus()[0];
+            if (focus instanceof FolderMatch) {
+                viewer.toggleCollapsed(focus);
+            }
+            else {
+                searchView.open(tree.getFocus()[0], false, false, true);
+            }
+        }
+    }
+});
+registerAction2(class OpenMatchToSideAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenMatchToSide,
+            title: {
+                value: ( nls.localize('OpenMatchToSide.label', "Open Match To Side")),
+                original: 'Open Match To Side'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchViewVisibleKey, FileMatchOrMatchFocusKey)),
+                primary: 2048  | 3 ,
+                mac: {
+                    primary: 256  | 3
+                },
+            },
+        });
+    }
+    run(accessor) {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (searchView) {
+            const tree = searchView.getControl();
+            searchView.open(tree.getFocus()[0], false, true, true);
+        }
+    }
+});
+registerAction2(class AddCursorsAtSearchResultsAction extends Action2 {
+    constructor() {
+        super({
+            id: AddCursorsAtSearchResults,
+            title: {
+                value: ( nls.localize('AddCursorsAtSearchResults.label', 'Add Cursors at Search Results')),
+                original: 'Add Cursors at Search Results'
+            },
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchViewVisibleKey, FileMatchOrMatchFocusKey)),
+                primary: 2048  | 1024  | 42 ,
+            },
+            category,
+        });
+    }
+    async run(accessor) {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (searchView) {
+            const tree = searchView.getControl();
+            searchView.openEditorWithMultiCursor(tree.getFocus()[0]);
+        }
+    }
+});
+registerAction2(class FocusNextInputAction extends Action2 {
+    constructor() {
+        super({
+            id: FocusNextInputActionId,
+            title: {
+                value: ( nls.localize('FocusNextInputAction.label', "Focus Next Input")),
+                original: 'Focus Next Input'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.or(( ContextKeyExpr.and(InSearchEditor, InputBoxFocusedKey)), ( ContextKeyExpr.and(SearchViewVisibleKey, InputBoxFocusedKey)))),
+                primary: 2048  | 18 ,
+            },
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusNextInput();
+        }
+        const searchView = getSearchView(accessor.get(IViewsService));
+        searchView?.focusNextInputBox();
+    }
+});
+registerAction2(class FocusPreviousInputAction extends Action2 {
+    constructor() {
+        super({
+            id: FocusPreviousInputActionId,
+            title: {
+                value: ( nls.localize('FocusPreviousInputAction.label', "Focus Previous Input")),
+                original: 'Focus Previous Input'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.or(( ContextKeyExpr.and(InSearchEditor, InputBoxFocusedKey)), ( ContextKeyExpr.and(
+                    SearchViewVisibleKey,
+                    InputBoxFocusedKey,
+                    ( SearchInputBoxFocusedKey.toNegated())
+                )))),
+                primary: 2048  | 16 ,
+            },
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusPrevInput();
+        }
+        const searchView = getSearchView(accessor.get(IViewsService));
+        searchView?.focusPreviousInputBox();
+    }
+});
+registerAction2(class FocusSearchFromResultsAction extends Action2 {
+    constructor() {
+        super({
+            id: FocusSearchFromResults,
+            title: {
+                value: ( nls.localize('FocusSearchFromResults.label', "Focus Search From Results")),
+                original: 'Focus Search From Results'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchViewVisibleKey, ( ContextKeyExpr.or(FirstMatchFocusKey, CONTEXT_ACCESSIBILITY_MODE_ENABLED)))),
+                primary: 2048  | 16 ,
+            },
+        });
+    }
+    run(accessor) {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        searchView?.focusPreviousInputBox();
+    }
+});
+registerAction2((_a = class ToggleSearchOnTypeAction extends Action2 {
+        constructor() {
+            super({
+                id: ToggleSearchOnTypeActionId,
+                title: {
+                    value: ( nls.localize('toggleTabs', 'Toggle Search on Type')),
+                    original: 'Toggle Search on Type'
+                },
+                category,
+            });
+        }
+        async run(accessor) {
+            const configurationService = accessor.get(IConfigurationService);
+            const searchOnType = configurationService.getValue(ToggleSearchOnTypeAction.searchOnTypeKey);
+            return configurationService.updateValue(ToggleSearchOnTypeAction.searchOnTypeKey, !searchOnType);
+        }
+    },
+    _a.searchOnTypeKey = 'search.searchOnType',
+    _a));
+registerAction2(class FocusSearchListCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: FocusSearchListCommandID,
+            title: {
+                value: ( nls.localize('focusSearchListCommandLabel', "Focus List")),
+                original: 'Focus List'
+            },
+            category,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        focusSearchListCommand(accessor);
+    }
+});
+registerAction2(class FocusNextSearchResultAction extends Action2 {
+    constructor() {
+        super({
+            id: FocusNextSearchResultActionId,
+            title: {
+                value: ( nls.localize('FocusNextSearchResult.label', 'Focus Next Search Result')),
+                original: 'Focus Next Search Result'
+            },
+            keybinding: [{
+                    primary: 62 ,
+                    weight: 200 ,
+                }],
+            category,
+            f1: true,
+            precondition: ( ContextKeyExpr.or(HasSearchResults, InSearchEditor)),
+        });
+    }
+    async run(accessor) {
+        return await focusNextSearchResult(accessor);
+    }
+});
+registerAction2(class FocusPreviousSearchResultAction extends Action2 {
+    constructor() {
+        super({
+            id: FocusPreviousSearchResultActionId,
+            title: {
+                value: ( nls.localize('FocusPreviousSearchResult.label', 'Focus Previous Search Result')),
+                original: 'Focus Previous Search Result'
+            },
+            keybinding: [{
+                    primary: 1024  | 62 ,
+                    weight: 200 ,
+                }],
+            category,
+            f1: true,
+            precondition: ( ContextKeyExpr.or(HasSearchResults, InSearchEditor)),
+        });
+    }
+    async run(accessor) {
+        return await focusPreviousSearchResult(accessor);
+    }
+});
+registerAction2(class ReplaceInFilesAction extends Action2 {
+    constructor() {
+        super({
+            id: ReplaceInFilesActionId,
+            title: {
+                value: ( nls.localize('replaceInFiles', 'Replace in Files')),
+                original: 'Replace in Files'
+            },
+            keybinding: [{
+                    primary: 2048  | 1024  | 38 ,
+                    weight: 200 ,
+                }],
+            category,
+            f1: true,
+            menu: [{
+                    id: MenuId.MenubarEditMenu,
+                    group: '4_find_global',
+                    order: 2
+                }],
+        });
+    }
+    async run(accessor) {
+        return await findOrReplaceInFiles(accessor, true);
+    }
+});
+function toggleCaseSensitiveCommand(accessor) {
+    const searchView = getSearchView(accessor.get(IViewsService));
+    searchView?.toggleCaseSensitive();
+}
+function toggleWholeWordCommand(accessor) {
+    const searchView = getSearchView(accessor.get(IViewsService));
+    searchView?.toggleWholeWords();
+}
+function toggleRegexCommand(accessor) {
+    const searchView = getSearchView(accessor.get(IViewsService));
+    searchView?.toggleRegex();
+}
+function togglePreserveCaseCommand(accessor) {
+    const searchView = getSearchView(accessor.get(IViewsService));
+    searchView?.togglePreserveCase();
+}
+const focusSearchListCommand = accessor => {
+    const viewsService = accessor.get(IViewsService);
+    openSearchView(viewsService).then(searchView => {
+        searchView?.moveFocusToResults();
+    });
+};
+async function focusNextSearchResult(accessor) {
+    const editorService = accessor.get(IEditorService);
+    const input = editorService.activeEditor;
+    if (input instanceof SearchEditorInput) {
+        return editorService.activeEditorPane.focusNextResult();
+    }
+    return openSearchView(accessor.get(IViewsService)).then(searchView => {
+        searchView?.selectNextMatch();
+    });
+}
+async function focusPreviousSearchResult(accessor) {
+    const editorService = accessor.get(IEditorService);
+    const input = editorService.activeEditor;
+    if (input instanceof SearchEditorInput) {
+        return editorService.activeEditorPane.focusPreviousResult();
+    }
+    return openSearchView(accessor.get(IViewsService)).then(searchView => {
+        searchView?.selectPreviousMatch();
+    });
+}
+async function findOrReplaceInFiles(accessor, expandSearchReplaceWidget) {
+    return openSearchView(accessor.get(IViewsService), false).then(openedView => {
+        if (openedView) {
+            const searchAndReplaceWidget = openedView.searchAndReplaceWidget;
+            searchAndReplaceWidget.toggleReplace(expandSearchReplaceWidget);
+            const updatedText = openedView.updateTextFromFindWidgetOrSelection({ allowUnselectedWord: !expandSearchReplaceWidget });
+            openedView.searchAndReplaceWidget.focus(undefined, updatedText, updatedText);
+        }
+    });
+}