@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

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

@@ -0,0 +1,628 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { CONTEXT_FIND_WIDGET_NOT_VISIBLE } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findModel.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextViewService, IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ContextScopedReplaceInput } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
+import { appendKeyBindingLabel, isSearchViewFocused, getSearchView } from './searchActionsBase.js';
+import { ReplaceActiveKey, SearchInputBoxFocusedKey, ReplaceInputBoxFocusedKey, ToggleCaseSensitiveCommandId, ToggleWholeWordCommandId, ToggleRegexCommandId, TogglePreserveCaseId, SearchViewVisibleKey } from '../common/constants.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Toggle } from 'monaco-editor/esm/vs/base/browser/ui/toggle/toggle.js';
+import { IViewsService } from '../../../common/views.js';
+import { searchReplaceAllIcon, searchHideReplaceIcon, searchShowContextIcon, searchShowReplaceIcon } from './searchIcons.js';
+import { ToggleSearchEditorContextLinesCommandId } from '../../searchEditor/browser/constants.js';
+import { showHistoryKeybindingHint } from 'monaco-editor/esm/vs/platform/history/browser/historyWidgetKeybindingHint.js';
+import { defaultToggleStyles, defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { NotebookFindFilters } from '../../notebook/browser/contrib/find/findFilters.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { NotebookEditorInput } from '../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
+import { SearchFindInput } from './searchFindInput.js';
+const SingleLineInputHeight = 26;
+class ReplaceAllAction extends Action {
+    constructor(_searchWidget) {
+        super(ReplaceAllAction.ID, '', ThemeIcon.asClassName(searchReplaceAllIcon), false);
+        this._searchWidget = _searchWidget;
+    }
+    set searchWidget(searchWidget) {
+        this._searchWidget = searchWidget;
+    }
+    run() {
+        if (this._searchWidget) {
+            return this._searchWidget.triggerReplaceAll();
+        }
+        return Promise.resolve(null);
+    }
+}
+ReplaceAllAction.ID = 'search.action.replaceAll';
+const ctrlKeyMod = ((isMacintosh ? 256  : 2048) );
+function stopPropagationForMultiLineUpwards(event, value, textarea) {
+    const isMultiline = !!value.match(/\n/);
+    if (textarea && (isMultiline || textarea.clientHeight > SingleLineInputHeight) && textarea.selectionStart > 0) {
+        event.stopPropagation();
+        return;
+    }
+}
+function stopPropagationForMultiLineDownwards(event, value, textarea) {
+    const isMultiline = !!value.match(/\n/);
+    if (textarea && (isMultiline || textarea.clientHeight > SingleLineInputHeight) && textarea.selectionEnd < textarea.value.length) {
+        event.stopPropagation();
+        return;
+    }
+}
+let SearchWidget = class SearchWidget extends Widget {
+    constructor(container, options, contextViewService, contextKeyService, keybindingService, clipboardServce, configurationService, accessibilityService, contextMenuService, instantiationService, editorService) {
+        super();
+        this.contextViewService = contextViewService;
+        this.contextKeyService = contextKeyService;
+        this.keybindingService = keybindingService;
+        this.clipboardServce = clipboardServce;
+        this.configurationService = configurationService;
+        this.accessibilityService = accessibilityService;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.ignoreGlobalFindBufferOnNextFocus = false;
+        this.previousGlobalFindBufferValue = null;
+        this._onSearchSubmit = this._register(( new Emitter()));
+        this.onSearchSubmit = this._onSearchSubmit.event;
+        this._onSearchCancel = this._register(( new Emitter()));
+        this.onSearchCancel = this._onSearchCancel.event;
+        this._onReplaceToggled = this._register(( new Emitter()));
+        this.onReplaceToggled = this._onReplaceToggled.event;
+        this._onReplaceStateChange = this._register(( new Emitter()));
+        this.onReplaceStateChange = this._onReplaceStateChange.event;
+        this._onPreserveCaseChange = this._register(( new Emitter()));
+        this.onPreserveCaseChange = this._onPreserveCaseChange.event;
+        this._onReplaceValueChanged = this._register(( new Emitter()));
+        this.onReplaceValueChanged = this._onReplaceValueChanged.event;
+        this._onReplaceAll = this._register(( new Emitter()));
+        this.onReplaceAll = this._onReplaceAll.event;
+        this._onBlur = this._register(( new Emitter()));
+        this.onBlur = this._onBlur.event;
+        this._onDidHeightChange = this._register(( new Emitter()));
+        this.onDidHeightChange = this._onDidHeightChange.event;
+        this._onDidToggleContext = ( new Emitter());
+        this.onDidToggleContext = this._onDidToggleContext.event;
+        this.replaceActive = ReplaceActiveKey.bindTo(this.contextKeyService);
+        this.searchInputBoxFocused = SearchInputBoxFocusedKey.bindTo(this.contextKeyService);
+        this.replaceInputBoxFocused = ReplaceInputBoxFocusedKey.bindTo(this.contextKeyService);
+        const notebookOptions = options.notebookOptions ??
+            {
+                isInNotebookMarkdownInput: true,
+                isInNotebookMarkdownPreview: true,
+                isInNotebookCellInput: true,
+                isInNotebookCellOutput: true
+            };
+        this._notebookFilters = this._register(( new NotebookFindFilters(
+            notebookOptions.isInNotebookMarkdownInput,
+            notebookOptions.isInNotebookMarkdownPreview,
+            notebookOptions.isInNotebookCellInput,
+            notebookOptions.isInNotebookCellOutput
+        )));
+        this._register(this._notebookFilters.onDidChange(() => {
+            if (this.searchInput instanceof SearchFindInput) {
+                this.searchInput.updateStyles();
+            }
+        }));
+        this._register(this.editorService.onDidEditorsChange((e) => {
+            if (this.searchInput instanceof SearchFindInput &&
+                e.event.editor instanceof NotebookEditorInput &&
+                ((e.event.kind === 3  || e.event.kind === 4) )) {
+                this.searchInput.filterVisible = this._hasNotebookOpen();
+            }
+        }));
+        this._replaceHistoryDelayer = ( new Delayer(500));
+        this.render(container, options);
+        this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor.accessibilitySupport')) {
+                this.updateAccessibilitySupport();
+            }
+        });
+        this.accessibilityService.onDidChangeScreenReaderOptimized(() => this.updateAccessibilitySupport());
+        this.updateAccessibilitySupport();
+    }
+    _hasNotebookOpen() {
+        const editors = this.editorService.editors;
+        return ( editors.some(editor => editor instanceof NotebookEditorInput));
+    }
+    getNotebookFilters() {
+        return this._notebookFilters;
+    }
+    focus(select = true, focusReplace = false, suppressGlobalSearchBuffer = false) {
+        this.ignoreGlobalFindBufferOnNextFocus = suppressGlobalSearchBuffer;
+        if (focusReplace && this.isReplaceShown()) {
+            if (this.replaceInput) {
+                this.replaceInput.focus();
+                if (select) {
+                    this.replaceInput.select();
+                }
+            }
+        }
+        else {
+            if (this.searchInput) {
+                this.searchInput.focus();
+                if (select) {
+                    this.searchInput.select();
+                }
+            }
+        }
+    }
+    setWidth(width) {
+        this.searchInput?.inputBox.layout();
+        if (this.replaceInput) {
+            this.replaceInput.width = width - 28;
+            this.replaceInput.inputBox.layout();
+        }
+    }
+    clear() {
+        this.searchInput?.clear();
+        this.replaceInput?.setValue('');
+        this.setReplaceAllActionState(false);
+    }
+    isReplaceShown() {
+        return this.replaceContainer ? !this.replaceContainer.classList.contains('disabled') : false;
+    }
+    isReplaceActive() {
+        return !!this.replaceActive.get();
+    }
+    getReplaceValue() {
+        return this.replaceInput?.getValue() ?? '';
+    }
+    toggleReplace(show) {
+        if (show === undefined || show !== this.isReplaceShown()) {
+            this.onToggleReplaceButton();
+        }
+    }
+    getSearchHistory() {
+        return this.searchInput?.inputBox.getHistory() ?? [];
+    }
+    getReplaceHistory() {
+        return this.replaceInput?.inputBox.getHistory() ?? [];
+    }
+    clearHistory() {
+        this.searchInput?.inputBox.clearHistory();
+        this.replaceInput?.inputBox.clearHistory();
+    }
+    showNextSearchTerm() {
+        this.searchInput?.inputBox.showNextValue();
+    }
+    showPreviousSearchTerm() {
+        this.searchInput?.inputBox.showPreviousValue();
+    }
+    showNextReplaceTerm() {
+        this.replaceInput?.inputBox.showNextValue();
+    }
+    showPreviousReplaceTerm() {
+        this.replaceInput?.inputBox.showPreviousValue();
+    }
+    searchInputHasFocus() {
+        return !!this.searchInputBoxFocused.get();
+    }
+    replaceInputHasFocus() {
+        return !!this.replaceInput?.inputBox.hasFocus();
+    }
+    focusReplaceAllAction() {
+        this.replaceActionBar?.focus(true);
+    }
+    focusRegexAction() {
+        this.searchInput?.focusOnRegex();
+    }
+    render(container, options) {
+        this.domNode = dom.append(container, dom.$('.search-widget'));
+        this.domNode.style.position = 'relative';
+        if (!options._hideReplaceToggle) {
+            this.renderToggleReplaceButton(this.domNode);
+        }
+        this.renderSearchInput(this.domNode, options);
+        this.renderReplaceInput(this.domNode, options);
+    }
+    updateAccessibilitySupport() {
+        this.searchInput?.setFocusInputOnOptionClick(!this.accessibilityService.isScreenReaderOptimized());
+    }
+    renderToggleReplaceButton(parent) {
+        const opts = {
+            buttonBackground: undefined,
+            buttonBorder: undefined,
+            buttonForeground: undefined,
+            buttonHoverBackground: undefined,
+            buttonSecondaryBackground: undefined,
+            buttonSecondaryForeground: undefined,
+            buttonSecondaryHoverBackground: undefined,
+            buttonSeparator: undefined
+        };
+        this.toggleReplaceButton = this._register(( new Button(parent, opts)));
+        this.toggleReplaceButton.element.setAttribute('aria-expanded', 'false');
+        this.toggleReplaceButton.element.classList.add('toggle-replace-button');
+        this.toggleReplaceButton.icon = searchHideReplaceIcon;
+        this.toggleReplaceButton.onDidClick(() => this.onToggleReplaceButton());
+        this.toggleReplaceButton.element.title = ( nls.localize('search.replace.toggle.button.title', "Toggle Replace"));
+    }
+    renderSearchInput(parent, options) {
+        const inputOptions = {
+            label: ( nls.localize('label.Search', 'Search: Type Search Term and press Enter to search')),
+            validation: (value) => this.validateSearchInput(value),
+            placeholder: ( nls.localize('search.placeHolder', "Search")),
+            appendCaseSensitiveLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding(ToggleCaseSensitiveCommandId)),
+            appendWholeWordsLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding(ToggleWholeWordCommandId)),
+            appendRegexLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding(ToggleRegexCommandId)),
+            history: options.searchHistory,
+            showHistoryHint: () => showHistoryKeybindingHint(this.keybindingService),
+            flexibleHeight: true,
+            flexibleMaxHeight: SearchWidget.INPUT_MAX_HEIGHT,
+            showCommonFindToggles: true,
+            inputBoxStyles: options.inputBoxStyles,
+            toggleStyles: options.toggleStyles
+        };
+        const searchInputContainer = dom.append(parent, dom.$('.search-container.input-box'));
+        this.searchInput = this._register(( new SearchFindInput(
+            searchInputContainer,
+            this.contextViewService,
+            inputOptions,
+            this.contextKeyService,
+            this.contextMenuService,
+            this.instantiationService,
+            this._notebookFilters,
+            this._hasNotebookOpen()
+        )));
+        this.searchInput.onKeyDown((keyboardEvent) => this.onSearchInputKeyDown(keyboardEvent));
+        this.searchInput.setValue(options.value || '');
+        this.searchInput.setRegex(!!options.isRegex);
+        this.searchInput.setCaseSensitive(!!options.isCaseSensitive);
+        this.searchInput.setWholeWords(!!options.isWholeWords);
+        this._register(this.searchInput.onCaseSensitiveKeyDown((keyboardEvent) => this.onCaseSensitiveKeyDown(keyboardEvent)));
+        this._register(this.searchInput.onRegexKeyDown((keyboardEvent) => this.onRegexKeyDown(keyboardEvent)));
+        this._register(this.searchInput.inputBox.onDidChange(() => this.onSearchInputChanged()));
+        this._register(this.searchInput.inputBox.onDidHeightChange(() => this._onDidHeightChange.fire()));
+        this._register(this.onReplaceValueChanged(() => {
+            this._replaceHistoryDelayer.trigger(() => this.replaceInput?.inputBox.addToHistory());
+        }));
+        this.searchInputFocusTracker = this._register(dom.trackFocus(this.searchInput.inputBox.inputElement));
+        this._register(this.searchInputFocusTracker.onDidFocus(async () => {
+            this.searchInputBoxFocused.set(true);
+            const useGlobalFindBuffer = this.searchConfiguration.globalFindClipboard;
+            if (!this.ignoreGlobalFindBufferOnNextFocus && useGlobalFindBuffer) {
+                const globalBufferText = await this.clipboardServce.readFindText();
+                if (globalBufferText && this.previousGlobalFindBufferValue !== globalBufferText) {
+                    this.searchInput?.inputBox.addToHistory();
+                    this.searchInput?.setValue(globalBufferText);
+                    this.searchInput?.select();
+                }
+                this.previousGlobalFindBufferValue = globalBufferText;
+            }
+            this.ignoreGlobalFindBufferOnNextFocus = false;
+        }));
+        this._register(this.searchInputFocusTracker.onDidBlur(() => this.searchInputBoxFocused.set(false)));
+        this.showContextToggle = ( new Toggle({
+            isChecked: false,
+            title: appendKeyBindingLabel(( nls.localize('showContext', "Toggle Context Lines")), this.keybindingService.lookupKeybinding(ToggleSearchEditorContextLinesCommandId)),
+            icon: searchShowContextIcon,
+            ...defaultToggleStyles
+        }));
+        this._register(this.showContextToggle.onChange(() => this.onContextLinesChanged()));
+        if (options.showContextToggle) {
+            this.contextLinesInput = ( new InputBox(
+                searchInputContainer,
+                this.contextViewService,
+                { type: 'number', inputBoxStyles: defaultInputBoxStyles }
+            ));
+            this.contextLinesInput.element.classList.add('context-lines-input');
+            this.contextLinesInput.value = '' + (this.configurationService.getValue('search').searchEditor.defaultNumberOfContextLines ?? 1);
+            this._register(this.contextLinesInput.onDidChange((value) => {
+                if (value !== '0') {
+                    this.showContextToggle.checked = true;
+                }
+                this.onContextLinesChanged();
+            }));
+            dom.append(searchInputContainer, this.showContextToggle.domNode);
+        }
+    }
+    onContextLinesChanged() {
+        this._onDidToggleContext.fire();
+        if (this.contextLinesInput.value.includes('-')) {
+            this.contextLinesInput.value = '0';
+        }
+        this._onDidToggleContext.fire();
+    }
+    setContextLines(lines) {
+        if (!this.contextLinesInput) {
+            return;
+        }
+        if (lines === 0) {
+            this.showContextToggle.checked = false;
+        }
+        else {
+            this.showContextToggle.checked = true;
+            this.contextLinesInput.value = '' + lines;
+        }
+    }
+    renderReplaceInput(parent, options) {
+        this.replaceContainer = dom.append(parent, dom.$('.replace-container.disabled'));
+        const replaceBox = dom.append(this.replaceContainer, dom.$('.replace-input'));
+        this.replaceInput = this._register(( new ContextScopedReplaceInput(replaceBox, this.contextViewService, {
+            label: ( nls.localize('label.Replace', 'Replace: Type replace term and press Enter to preview')),
+            placeholder: ( nls.localize('search.replace.placeHolder', "Replace")),
+            appendPreserveCaseLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding(TogglePreserveCaseId)),
+            history: options.replaceHistory,
+            showHistoryHint: () => showHistoryKeybindingHint(this.keybindingService),
+            flexibleHeight: true,
+            flexibleMaxHeight: SearchWidget.INPUT_MAX_HEIGHT,
+            inputBoxStyles: options.inputBoxStyles,
+            toggleStyles: options.toggleStyles
+        }, this.contextKeyService, true)));
+        this._register(this.replaceInput.onDidOptionChange(viaKeyboard => {
+            if (!viaKeyboard) {
+                if (this.replaceInput) {
+                    this._onPreserveCaseChange.fire(this.replaceInput.getPreserveCase());
+                }
+            }
+        }));
+        this.replaceInput.onKeyDown((keyboardEvent) => this.onReplaceInputKeyDown(keyboardEvent));
+        this.replaceInput.setValue(options.replaceValue || '');
+        this._register(this.replaceInput.inputBox.onDidChange(() => this._onReplaceValueChanged.fire()));
+        this._register(this.replaceInput.inputBox.onDidHeightChange(() => this._onDidHeightChange.fire()));
+        this.replaceAllAction = ( new ReplaceAllAction(this));
+        this.replaceAllAction.label = SearchWidget.REPLACE_ALL_DISABLED_LABEL;
+        this.replaceActionBar = this._register(( new ActionBar(this.replaceContainer)));
+        this.replaceActionBar.push([this.replaceAllAction], { icon: true, label: false });
+        this.onkeydown(this.replaceActionBar.domNode, (keyboardEvent) => this.onReplaceActionbarKeyDown(keyboardEvent));
+        this.replaceInputFocusTracker = this._register(dom.trackFocus(this.replaceInput.inputBox.inputElement));
+        this._register(this.replaceInputFocusTracker.onDidFocus(() => this.replaceInputBoxFocused.set(true)));
+        this._register(this.replaceInputFocusTracker.onDidBlur(() => this.replaceInputBoxFocused.set(false)));
+        this._register(this.replaceInput.onPreserveCaseKeyDown((keyboardEvent) => this.onPreserveCaseKeyDown(keyboardEvent)));
+    }
+    triggerReplaceAll() {
+        this._onReplaceAll.fire();
+        return Promise.resolve(null);
+    }
+    onToggleReplaceButton() {
+        this.replaceContainer?.classList.toggle('disabled');
+        if (this.isReplaceShown()) {
+            this.toggleReplaceButton?.element.classList.remove(...ThemeIcon.asClassNameArray(searchHideReplaceIcon));
+            this.toggleReplaceButton?.element.classList.add(...ThemeIcon.asClassNameArray(searchShowReplaceIcon));
+        }
+        else {
+            this.toggleReplaceButton?.element.classList.remove(...ThemeIcon.asClassNameArray(searchShowReplaceIcon));
+            this.toggleReplaceButton?.element.classList.add(...ThemeIcon.asClassNameArray(searchHideReplaceIcon));
+        }
+        this.toggleReplaceButton?.element.setAttribute('aria-expanded', this.isReplaceShown() ? 'true' : 'false');
+        this.updateReplaceActiveState();
+        this._onReplaceToggled.fire();
+    }
+    setValue(value) {
+        this.searchInput?.setValue(value);
+    }
+    setReplaceAllActionState(enabled) {
+        if (this.replaceAllAction && (this.replaceAllAction.enabled !== enabled)) {
+            this.replaceAllAction.enabled = enabled;
+            this.replaceAllAction.label = enabled ? SearchWidget.REPLACE_ALL_ENABLED_LABEL(this.keybindingService) : SearchWidget.REPLACE_ALL_DISABLED_LABEL;
+            this.updateReplaceActiveState();
+        }
+    }
+    updateReplaceActiveState() {
+        const currentState = this.isReplaceActive();
+        const newState = this.isReplaceShown() && !!this.replaceAllAction?.enabled;
+        if (currentState !== newState) {
+            this.replaceActive.set(newState);
+            this._onReplaceStateChange.fire(newState);
+            this.replaceInput?.inputBox.layout();
+        }
+    }
+    validateSearchInput(value) {
+        if (value.length === 0) {
+            return null;
+        }
+        if (!(this.searchInput?.getRegex())) {
+            return null;
+        }
+        return null;
+    }
+    onSearchInputChanged() {
+        this.searchInput?.clearMessage();
+        this.setReplaceAllActionState(false);
+        if (this.searchConfiguration.searchOnType) {
+            if (this.searchInput?.getRegex()) {
+                try {
+                    const regex = ( new RegExp(this.searchInput.getValue(), 'ug'));
+                    const matchienessHeuristic = `
+								~!@#$%^&*()_+
+								\`1234567890-=
+								qwertyuiop[]\\
+								QWERTYUIOP{}|
+								asdfghjkl;'
+								ASDFGHJKL:"
+								zxcvbnm,./
+								ZXCVBNM<>? `.match(regex)?.length ?? 0;
+                    const delayMultiplier = matchienessHeuristic < 50 ? 1 :
+                        matchienessHeuristic < 100 ? 5 :
+                            10;
+                    this.submitSearch(true, this.searchConfiguration.searchOnTypeDebouncePeriod * delayMultiplier);
+                }
+                catch {
+                }
+            }
+            else {
+                this.submitSearch(true, this.searchConfiguration.searchOnTypeDebouncePeriod);
+            }
+        }
+    }
+    onSearchInputKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(ctrlKeyMod | 3 )) {
+            this.searchInput?.inputBox.insertAtCursor('\n');
+            keyboardEvent.preventDefault();
+        }
+        if (keyboardEvent.equals(3 )) {
+            this.searchInput?.onSearchSubmit();
+            this.submitSearch();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(9 )) {
+            this._onSearchCancel.fire({ focus: true });
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(2 )) {
+            if (this.isReplaceShown()) {
+                this.replaceInput?.focus();
+            }
+            else {
+                this.searchInput?.focusOnCaseSensitive();
+            }
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(16 )) {
+            stopPropagationForMultiLineUpwards(keyboardEvent, this.searchInput?.getValue() ?? '', this.searchInput?.domNode.querySelector('textarea') ?? null);
+        }
+        else if (keyboardEvent.equals(18 )) {
+            stopPropagationForMultiLineDownwards(keyboardEvent, this.searchInput?.getValue() ?? '', this.searchInput?.domNode.querySelector('textarea') ?? null);
+        }
+    }
+    onCaseSensitiveKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(1024  | 2 )) {
+            if (this.isReplaceShown()) {
+                this.replaceInput?.focus();
+                keyboardEvent.preventDefault();
+            }
+        }
+    }
+    onRegexKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(2 )) {
+            if (this.isReplaceShown()) {
+                this.replaceInput?.focusOnPreserve();
+                keyboardEvent.preventDefault();
+            }
+        }
+    }
+    onPreserveCaseKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(2 )) {
+            if (this.isReplaceActive()) {
+                this.focusReplaceAllAction();
+            }
+            else {
+                this._onBlur.fire();
+            }
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(1024  | 2 )) {
+            this.focusRegexAction();
+            keyboardEvent.preventDefault();
+        }
+    }
+    onReplaceInputKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(ctrlKeyMod | 3 )) {
+            this.replaceInput?.inputBox.insertAtCursor('\n');
+            keyboardEvent.preventDefault();
+        }
+        if (keyboardEvent.equals(3 )) {
+            this.submitSearch();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(2 )) {
+            this.searchInput?.focusOnCaseSensitive();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(1024  | 2 )) {
+            this.searchInput?.focus();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(16 )) {
+            stopPropagationForMultiLineUpwards(keyboardEvent, this.replaceInput?.getValue() ?? '', this.replaceInput?.domNode.querySelector('textarea') ?? null);
+        }
+        else if (keyboardEvent.equals(18 )) {
+            stopPropagationForMultiLineDownwards(keyboardEvent, this.replaceInput?.getValue() ?? '', this.replaceInput?.domNode.querySelector('textarea') ?? null);
+        }
+    }
+    onReplaceActionbarKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(1024  | 2 )) {
+            this.focusRegexAction();
+            keyboardEvent.preventDefault();
+        }
+    }
+    async submitSearch(triggeredOnType = false, delay = 0) {
+        this.searchInput?.validate();
+        if (!this.searchInput?.inputBox.isInputValid()) {
+            return;
+        }
+        const value = this.searchInput.getValue();
+        const useGlobalFindBuffer = this.searchConfiguration.globalFindClipboard;
+        if (value && useGlobalFindBuffer) {
+            await this.clipboardServce.writeFindText(value);
+        }
+        this._onSearchSubmit.fire({ triggeredOnType, delay });
+    }
+    getContextLines() {
+        return this.showContextToggle.checked ? +this.contextLinesInput.value : 0;
+    }
+    modifyContextLines(increase) {
+        const current = +this.contextLinesInput.value;
+        const modified = current + (increase ? 1 : -1);
+        this.showContextToggle.checked = modified !== 0;
+        this.contextLinesInput.value = '' + modified;
+    }
+    toggleContextLines() {
+        this.showContextToggle.checked = !this.showContextToggle.checked;
+        this.onContextLinesChanged();
+    }
+    dispose() {
+        this.setReplaceAllActionState(false);
+        super.dispose();
+    }
+    get searchConfiguration() {
+        return this.configurationService.getValue('search');
+    }
+};
+SearchWidget.INPUT_MAX_HEIGHT = 134;
+SearchWidget.REPLACE_ALL_DISABLED_LABEL = ( nls.localize(
+    'search.action.replaceAll.disabled.label',
+    "Replace All (Submit Search to Enable)"
+));
+SearchWidget.REPLACE_ALL_ENABLED_LABEL = (keyBindingService2) => {
+    const kb = keyBindingService2.lookupKeybinding(ReplaceAllAction.ID);
+    return appendKeyBindingLabel(( nls.localize('search.action.replaceAll.enabled.label', "Replace All")), kb);
+};
+SearchWidget = ( __decorate([
+    ( __param(2, IContextViewService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IClipboardService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IAccessibilityService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, IEditorService))
+], SearchWidget));
+function registerContributions() {
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: ReplaceAllAction.ID,
+        weight: 200 ,
+        when: ( ContextKeyExpr.and(
+            SearchViewVisibleKey,
+            ReplaceActiveKey,
+            CONTEXT_FIND_WIDGET_NOT_VISIBLE
+        )),
+        primary: 512  | 2048  | 3 ,
+        handler: accessor => {
+            const viewsService = accessor.get(IViewsService);
+            if (isSearchViewFocused(viewsService)) {
+                const searchView = getSearchView(viewsService);
+                if (searchView) {
+                    ( new ReplaceAllAction(searchView.searchAndReplaceWidget)).run();
+                }
+            }
+        }
+    });
+}
+export { SearchWidget, registerContributions };

package/dist/vscode/vs/workbench/contrib/search/common/constants.js

@@ -1,2 +1,31 @@
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const OpenInEditorCommandId = 'search.action.openInEditor';
+const ToggleCaseSensitiveCommandId = 'toggleSearchCaseSensitive';
+const ToggleWholeWordCommandId = 'toggleSearchWholeWord';
+const ToggleRegexCommandId = 'toggleSearchRegex';
+const TogglePreserveCaseId = 'toggleSearchPreserveCase';
 const ShowAllSymbolsActionId = 'workbench.action.showAllSymbols';
-export { ShowAllSymbolsActionId };
+const SearchViewVisibleKey = ( new RawContextKey('searchViewletVisible', true));
+const SearchViewFocusedKey = ( new RawContextKey('searchViewletFocus', false));
+const InputBoxFocusedKey = ( new RawContextKey('inputBoxFocus', false));
+const SearchInputBoxFocusedKey = ( new RawContextKey('searchInputBoxFocus', false));
+const ReplaceInputBoxFocusedKey = ( new RawContextKey('replaceInputBoxFocus', false));
+const PatternIncludesFocusedKey = ( new RawContextKey('patternIncludesInputBoxFocus', false));
+const PatternExcludesFocusedKey = ( new RawContextKey('patternExcludesInputBoxFocus', false));
+const ReplaceActiveKey = ( new RawContextKey('replaceActive', false));
+const HasSearchResults = ( new RawContextKey('hasSearchResult', false));
+const FirstMatchFocusKey = ( new RawContextKey('firstMatchFocus', false));
+const FileMatchOrMatchFocusKey = ( new RawContextKey('fileMatchOrMatchFocus', false));
+const FileMatchOrFolderMatchFocusKey = ( new RawContextKey('fileMatchOrFolderMatchFocus', false));
+const FileMatchOrFolderMatchWithResourceFocusKey = ( new RawContextKey('fileMatchOrFolderMatchWithResourceFocus', false));
+const FileFocusKey = ( new RawContextKey('fileMatchFocus', false));
+const FolderFocusKey = ( new RawContextKey('folderMatchFocus', false));
+const ResourceFolderFocusKey = ( new RawContextKey('folderMatchWithResourceFocus', false));
+const IsEditableItemKey = ( new RawContextKey('isEditableItem', true));
+const MatchFocusKey = ( new RawContextKey('matchFocus', false));
+const ViewHasSearchPatternKey = ( new RawContextKey('viewHasSearchPattern', false));
+const ViewHasReplacePatternKey = ( new RawContextKey('viewHasReplacePattern', false));
+const ViewHasFilePatternKey = ( new RawContextKey('viewHasFilePattern', false));
+const ViewHasSomeCollapsibleKey = ( new RawContextKey('viewHasSomeCollapsibleResult', false));
+const InTreeViewKey = ( new RawContextKey('inTreeView', false));
+export { FileFocusKey, FileMatchOrFolderMatchFocusKey, FileMatchOrFolderMatchWithResourceFocusKey, FileMatchOrMatchFocusKey, FirstMatchFocusKey, FolderFocusKey, HasSearchResults, InTreeViewKey, InputBoxFocusedKey, IsEditableItemKey, MatchFocusKey, OpenInEditorCommandId, PatternExcludesFocusedKey, PatternIncludesFocusedKey, ReplaceActiveKey, ReplaceInputBoxFocusedKey, ResourceFolderFocusKey, SearchInputBoxFocusedKey, SearchViewFocusedKey, SearchViewVisibleKey, ShowAllSymbolsActionId, ToggleCaseSensitiveCommandId, TogglePreserveCaseId, ToggleRegexCommandId, ToggleWholeWordCommandId, ViewHasFilePatternKey, ViewHasReplacePatternKey, ViewHasSearchPatternKey, ViewHasSomeCollapsibleKey };