@codingame/monaco-vscode-api 1.85.0 → 1.85.1

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget.js

@@ -0,0 +1,663 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { FindInput } from 'monaco-editor/esm/vs/base/browser/ui/findinput/findInput.js';
+import { ProgressBar } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import './notebookFindReplaceWidget.css.js';
+import { FindReplaceState } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findState.js';
+import { SimpleButton, findPreviousMatchIcon, findNextMatchIcon, findReplaceIcon, findReplaceAllIcon } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findWidget.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ContextScopedReplaceInput, registerAndCreateHistoryNavigationContext } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
+import { 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 { registerIcon, widgetClose } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { parseReplaceString, ReplacePattern } from 'monaco-editor/esm/vs/editor/contrib/find/browser/replacePattern.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Action, ActionRunner, Separator } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { DropdownMenuActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { filterIcon } from '../../../../extensions/browser/extensionsIcons.js';
+import { NotebookFindFilters } from './findFilters.js';
+import { isSafari } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Sash } from 'monaco-editor/esm/vs/base/browser/ui/sash/sash.js';
+import { defaultProgressBarStyles, defaultInputBoxStyles, defaultToggleStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { NotebookSetting } from '../../../common/notebookCommon.js';
+const NLS_FIND_INPUT_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.find',
+    "Find"
+));
+const NLS_FIND_INPUT_PLACEHOLDER = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'placeholder.find',
+    "Find"
+));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.previousMatchButton',
+    "Previous Match"
+));
+const NLS_NEXT_MATCH_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.nextMatchButton',
+    "Next Match"
+));
+const NLS_CLOSE_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.closeButton',
+    "Close"
+));
+const NLS_TOGGLE_REPLACE_MODE_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.toggleReplaceButton',
+    "Toggle Replace"
+));
+const NLS_REPLACE_INPUT_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.replace',
+    "Replace"
+));
+const NLS_REPLACE_INPUT_PLACEHOLDER = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'placeholder.replace',
+    "Replace"
+));
+const NLS_REPLACE_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.replaceButton',
+    "Replace"
+));
+const NLS_REPLACE_ALL_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'label.replaceAllButton',
+    "Replace All"
+));
+registerIcon('find-filter', Codicon.filter, ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'findFilterIcon',
+    'Icon for Find Filter in find widget.'
+)));
+const NOTEBOOK_FIND_FILTERS = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'notebook.find.filter.filterAction',
+    "Find Filters"
+));
+const NOTEBOOK_FIND_IN_MARKUP_INPUT = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'notebook.find.filter.findInMarkupInput',
+    "Markdown Source"
+));
+const NOTEBOOK_FIND_IN_MARKUP_PREVIEW = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'notebook.find.filter.findInMarkupPreview',
+    "Rendered Markdown"
+));
+const NOTEBOOK_FIND_IN_CODE_INPUT = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'notebook.find.filter.findInCodeInput',
+    "Code Cell Source"
+));
+const NOTEBOOK_FIND_IN_CODE_OUTPUT = ( nls.localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget',
+    'notebook.find.filter.findInCodeOutput',
+    "Code Cell Output"
+));
+const NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH = 318;
+const NOTEBOOK_FIND_WIDGET_INITIAL_HORIZONTAL_PADDING = 4;
+let NotebookFindFilterActionViewItem = class NotebookFindFilterActionViewItem extends DropdownMenuActionViewItem {
+    constructor(filters, action, actionRunner, contextMenuService) {
+        super(action, { getActions: () => this.getActions() }, contextMenuService, {
+            actionRunner,
+            classNames: action.class,
+            anchorAlignmentProvider: () => 1
+        });
+        this.filters = filters;
+    }
+    render(container) {
+        super.render(container);
+        this.updateChecked();
+    }
+    getActions() {
+        const markdownInput = {
+            checked: this.filters.markupInput,
+            class: undefined,
+            enabled: true,
+            id: 'findInMarkdownInput',
+            label: NOTEBOOK_FIND_IN_MARKUP_INPUT,
+            run: async () => {
+                this.filters.markupInput = !this.filters.markupInput;
+            },
+            tooltip: ''
+        };
+        const markdownPreview = {
+            checked: this.filters.markupPreview,
+            class: undefined,
+            enabled: true,
+            id: 'findInMarkdownInput',
+            label: NOTEBOOK_FIND_IN_MARKUP_PREVIEW,
+            run: async () => {
+                this.filters.markupPreview = !this.filters.markupPreview;
+            },
+            tooltip: ''
+        };
+        const codeInput = {
+            checked: this.filters.codeInput,
+            class: undefined,
+            enabled: true,
+            id: 'findInCodeInput',
+            label: NOTEBOOK_FIND_IN_CODE_INPUT,
+            run: async () => {
+                this.filters.codeInput = !this.filters.codeInput;
+            },
+            tooltip: ''
+        };
+        const codeOutput = {
+            checked: this.filters.codeOutput,
+            class: undefined,
+            enabled: true,
+            id: 'findInCodeOutput',
+            label: NOTEBOOK_FIND_IN_CODE_OUTPUT,
+            run: async () => {
+                this.filters.codeOutput = !this.filters.codeOutput;
+            },
+            tooltip: '',
+            dispose: () => null
+        };
+        if (isSafari) {
+            return [
+                markdownInput,
+                codeInput
+            ];
+        }
+        else {
+            return [
+                markdownInput,
+                markdownPreview,
+                ( new Separator()),
+                codeInput,
+                codeOutput,
+            ];
+        }
+    }
+    updateChecked() {
+        this.element.classList.toggle('checked', this._action.checked);
+    }
+};
+NotebookFindFilterActionViewItem = ( __decorate([
+    ( __param(3, IContextMenuService))
+], NotebookFindFilterActionViewItem));
+class NotebookFindInputFilterButton extends Disposable {
+    constructor(filters, contextMenuService, instantiationService, options, tooltip = NOTEBOOK_FIND_FILTERS) {
+        super();
+        this.filters = filters;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this._actionbar = null;
+        this._toggleStyles = options.toggleStyles;
+        this._filtersAction = ( new Action(
+            'notebookFindFilterAction',
+            tooltip,
+            'notebook-filters ' + ThemeIcon.asClassName(filterIcon)
+        ));
+        this._filtersAction.checked = false;
+        this._filterButtonContainer = dom.$('.find-filter-button');
+        this._filterButtonContainer.classList.add('monaco-custom-toggle');
+        this.createFilters(this._filterButtonContainer);
+    }
+    get container() {
+        return this._filterButtonContainer;
+    }
+    get width() {
+        return 2  + 2  + 2  + 16 ;
+    }
+    applyStyles(filterChecked) {
+        const toggleStyles = this._toggleStyles;
+        this._filterButtonContainer.style.border = '1px solid transparent';
+        this._filterButtonContainer.style.borderRadius = '3px';
+        this._filterButtonContainer.style.borderColor = (filterChecked && toggleStyles.inputActiveOptionBorder) || '';
+        this._filterButtonContainer.style.color = (filterChecked && toggleStyles.inputActiveOptionForeground) || 'inherit';
+        this._filterButtonContainer.style.backgroundColor = (filterChecked && toggleStyles.inputActiveOptionBackground) || '';
+    }
+    createFilters(container) {
+        this._actionbar = this._register(( new ActionBar(container, {
+            actionViewItemProvider: action => {
+                if (action.id === this._filtersAction.id) {
+                    return this.instantiationService.createInstance(NotebookFindFilterActionViewItem, this.filters, action, ( new ActionRunner()));
+                }
+                return undefined;
+            }
+        })));
+        this._actionbar.push(this._filtersAction, { icon: true, label: false });
+    }
+}
+class NotebookFindInput extends FindInput {
+    constructor(filters, contextKeyService, contextMenuService, instantiationService, parent, contextViewProvider, options) {
+        super(parent, contextViewProvider, options);
+        this.filters = filters;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this._filterChecked = false;
+        this._register(registerAndCreateHistoryNavigationContext(contextKeyService, this.inputBox));
+        this._findFilter = this._register(( new NotebookFindInputFilterButton(filters, contextMenuService, instantiationService, options)));
+        this.inputBox.paddingRight = (this.caseSensitive?.width() ?? 0) + (this.wholeWords?.width() ?? 0) + (this.regex?.width() ?? 0) + this._findFilter.width;
+        this.controls.appendChild(this._findFilter.container);
+    }
+    setEnabled(enabled) {
+        super.setEnabled(enabled);
+        if (enabled && !this._filterChecked) {
+            this.regex?.enable();
+        }
+        else {
+            this.regex?.disable();
+        }
+    }
+    updateFilterState(changed) {
+        this._filterChecked = changed;
+        if (this.regex) {
+            if (this._filterChecked) {
+                this.regex.disable();
+                this.regex.domNode.tabIndex = -1;
+                this.regex.domNode.classList.toggle('disabled', true);
+            }
+            else {
+                this.regex.enable();
+                this.regex.domNode.tabIndex = 0;
+                this.regex.domNode.classList.toggle('disabled', false);
+            }
+        }
+        this._findFilter.applyStyles(this._filterChecked);
+    }
+    getCellToolbarActions(menu) {
+        const primary = [];
+        const secondary = [];
+        const result = { primary, secondary };
+        createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, result, g => /^inline/.test(g));
+        return result;
+    }
+}
+let SimpleFindReplaceWidget = class SimpleFindReplaceWidget extends Widget {
+    constructor(_contextViewService, contextKeyService, _configurationService, contextMenuService, instantiationService, _state = ( new FindReplaceState()), _notebookEditor) {
+        super();
+        this._contextViewService = _contextViewService;
+        this._configurationService = _configurationService;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this._state = _state;
+        this._notebookEditor = _notebookEditor;
+        this._resizeOriginalWidth = NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH;
+        this._isVisible = false;
+        this._isReplaceVisible = false;
+        this.foundMatch = false;
+        const findScope = this._configurationService.getValue(NotebookSetting.findScope) ?? { markupSource: true, markupPreview: true, codeSource: true, codeOutput: true };
+        this._filters = ( new NotebookFindFilters(
+            findScope.markupSource,
+            findScope.markupPreview,
+            findScope.codeSource,
+            findScope.codeOutput
+        ));
+        this._state.change({ filters: this._filters }, false);
+        this._filters.onDidChange(() => {
+            this._state.change({ filters: this._filters }, false);
+        });
+        this._domNode = document.createElement('div');
+        this._domNode.classList.add('simple-fr-find-part-wrapper');
+        this._register(this._state.onFindReplaceStateChange((e) => this._onStateChanged(e)));
+        this._scopedContextKeyService = contextKeyService.createScoped(this._domNode);
+        const progressContainer = dom.$('.find-replace-progress');
+        this._progressBar = ( new ProgressBar(progressContainer, defaultProgressBarStyles));
+        this._domNode.appendChild(progressContainer);
+        const isInteractiveWindow = contextKeyService.getContextKeyValue('notebookType') === 'interactive';
+        this._toggleReplaceBtn = this._register(( new SimpleButton({
+            label: NLS_TOGGLE_REPLACE_MODE_BTN_LABEL,
+            className: 'codicon toggle left',
+            onTrigger: isInteractiveWindow ? () => { } :
+                () => {
+                    this._isReplaceVisible = !this._isReplaceVisible;
+                    this._state.change({ isReplaceRevealed: this._isReplaceVisible }, false);
+                    this._updateReplaceViewDisplay();
+                }
+        })));
+        this._toggleReplaceBtn.setEnabled(!isInteractiveWindow);
+        this._toggleReplaceBtn.setExpanded(this._isReplaceVisible);
+        this._domNode.appendChild(this._toggleReplaceBtn.domNode);
+        this._innerFindDomNode = document.createElement('div');
+        this._innerFindDomNode.classList.add('simple-fr-find-part');
+        this._findInput = this._register(( new NotebookFindInput(
+            this._filters,
+            this._scopedContextKeyService,
+            this.contextMenuService,
+            this.instantiationService,
+            null,
+            this._contextViewService,
+            {
+                label: NLS_FIND_INPUT_LABEL,
+                placeholder: NLS_FIND_INPUT_PLACEHOLDER,
+                validation: (value) => {
+                    if (value.length === 0 || !this._findInput.getRegex()) {
+                        return null;
+                    }
+                    try {
+                        return null;
+                    }
+                    catch (e) {
+                        this.foundMatch = false;
+                        this.updateButtons(this.foundMatch);
+                        return { content: e.message };
+                    }
+                },
+                flexibleWidth: true,
+                showCommonFindToggles: true,
+                inputBoxStyles: defaultInputBoxStyles,
+                toggleStyles: defaultToggleStyles
+            }
+        )));
+        this._updateHistoryDelayer = ( new Delayer(500));
+        this.oninput(this._findInput.domNode, (e) => {
+            this.foundMatch = this.onInputChanged();
+            this.updateButtons(this.foundMatch);
+            this._delayedUpdateHistory();
+        });
+        this._register(this._findInput.inputBox.onDidChange(() => {
+            this._state.change({ searchString: this._findInput.getValue() }, true);
+        }));
+        this._findInput.setRegex(!!this._state.isRegex);
+        this._findInput.setCaseSensitive(!!this._state.matchCase);
+        this._findInput.setWholeWords(!!this._state.wholeWord);
+        this._register(this._findInput.onDidOptionChange(() => {
+            this._state.change({
+                isRegex: this._findInput.getRegex(),
+                wholeWord: this._findInput.getWholeWords(),
+                matchCase: this._findInput.getCaseSensitive()
+            }, true);
+        }));
+        this._register(this._state.onFindReplaceStateChange(() => {
+            this._findInput.setRegex(this._state.isRegex);
+            this._findInput.setWholeWords(this._state.wholeWord);
+            this._findInput.setCaseSensitive(this._state.matchCase);
+            this._replaceInput.setPreserveCase(this._state.preserveCase);
+            this.findFirst();
+        }));
+        this._matchesCount = document.createElement('div');
+        this._matchesCount.className = 'matchesCount';
+        this._updateMatchesCount();
+        this.prevBtn = this._register(( new SimpleButton({
+            label: NLS_PREVIOUS_MATCH_BTN_LABEL,
+            icon: findPreviousMatchIcon,
+            onTrigger: () => {
+                this.find(true);
+            }
+        })));
+        this.nextBtn = this._register(( new SimpleButton({
+            label: NLS_NEXT_MATCH_BTN_LABEL,
+            icon: findNextMatchIcon,
+            onTrigger: () => {
+                this.find(false);
+            }
+        })));
+        const closeBtn = this._register(( new SimpleButton({
+            label: NLS_CLOSE_BTN_LABEL,
+            icon: widgetClose,
+            onTrigger: () => {
+                this.hide();
+            }
+        })));
+        this._innerFindDomNode.appendChild(this._findInput.domNode);
+        this._innerFindDomNode.appendChild(this._matchesCount);
+        this._innerFindDomNode.appendChild(this.prevBtn.domNode);
+        this._innerFindDomNode.appendChild(this.nextBtn.domNode);
+        this._innerFindDomNode.appendChild(closeBtn.domNode);
+        this._domNode.appendChild(this._innerFindDomNode);
+        this.onkeyup(this._innerFindDomNode, e => {
+            if (e.equals(9 )) {
+                this.hide();
+                e.preventDefault();
+                return;
+            }
+        });
+        this._focusTracker = this._register(dom.trackFocus(this._domNode));
+        this._register(this._focusTracker.onDidFocus(this.onFocusTrackerFocus.bind(this)));
+        this._register(this._focusTracker.onDidBlur(this.onFocusTrackerBlur.bind(this)));
+        this._findInputFocusTracker = this._register(dom.trackFocus(this._findInput.domNode));
+        this._register(this._findInputFocusTracker.onDidFocus(this.onFindInputFocusTrackerFocus.bind(this)));
+        this._register(this._findInputFocusTracker.onDidBlur(this.onFindInputFocusTrackerBlur.bind(this)));
+        this._register(dom.addDisposableListener(this._innerFindDomNode, 'click', (event) => {
+            event.stopPropagation();
+        }));
+        this._innerReplaceDomNode = document.createElement('div');
+        this._innerReplaceDomNode.classList.add('simple-fr-replace-part');
+        this._replaceInput = this._register(( new ContextScopedReplaceInput(null, undefined, {
+            label: NLS_REPLACE_INPUT_LABEL,
+            placeholder: NLS_REPLACE_INPUT_PLACEHOLDER,
+            history: [],
+            inputBoxStyles: defaultInputBoxStyles,
+            toggleStyles: defaultToggleStyles
+        }, contextKeyService, false)));
+        this._innerReplaceDomNode.appendChild(this._replaceInput.domNode);
+        this._replaceInputFocusTracker = this._register(dom.trackFocus(this._replaceInput.domNode));
+        this._register(this._replaceInputFocusTracker.onDidFocus(this.onReplaceInputFocusTrackerFocus.bind(this)));
+        this._register(this._replaceInputFocusTracker.onDidBlur(this.onReplaceInputFocusTrackerBlur.bind(this)));
+        this._register(this._replaceInput.inputBox.onDidChange(() => {
+            this._state.change({ replaceString: this._replaceInput.getValue() }, true);
+        }));
+        this._domNode.appendChild(this._innerReplaceDomNode);
+        this._updateReplaceViewDisplay();
+        this._replaceBtn = this._register(( new SimpleButton({
+            label: NLS_REPLACE_BTN_LABEL,
+            icon: findReplaceIcon,
+            onTrigger: () => {
+                this.replaceOne();
+            }
+        })));
+        this._replaceAllBtn = this._register(( new SimpleButton({
+            label: NLS_REPLACE_ALL_BTN_LABEL,
+            icon: findReplaceAllIcon,
+            onTrigger: () => {
+                this.replaceAll();
+            }
+        })));
+        this._innerReplaceDomNode.appendChild(this._replaceBtn.domNode);
+        this._innerReplaceDomNode.appendChild(this._replaceAllBtn.domNode);
+        this._resizeSash = this._register(( new Sash(
+            this._domNode,
+            { getVerticalSashLeft: () => 0 },
+            { orientation: 0 , size: 2 }
+        )));
+        this._register(this._resizeSash.onDidStart(() => {
+            this._resizeOriginalWidth = this._getDomWidth();
+        }));
+        this._register(this._resizeSash.onDidChange((evt) => {
+            let width = this._resizeOriginalWidth + evt.startX - evt.currentX;
+            if (width < NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH) {
+                width = NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH;
+            }
+            const maxWidth = this._getMaxWidth();
+            if (width > maxWidth) {
+                width = maxWidth;
+            }
+            this._domNode.style.width = `${width}px`;
+            if (this._isReplaceVisible) {
+                this._replaceInput.width = dom.getTotalWidth(this._findInput.domNode);
+            }
+            this._findInput.inputBox.layout();
+        }));
+        this._register(this._resizeSash.onDidReset(() => {
+            const currentWidth = this._getDomWidth();
+            let width = NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH;
+            if (currentWidth <= NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH) {
+                width = this._getMaxWidth();
+            }
+            this._domNode.style.width = `${width}px`;
+            if (this._isReplaceVisible) {
+                this._replaceInput.width = dom.getTotalWidth(this._findInput.domNode);
+            }
+            this._findInput.inputBox.layout();
+        }));
+    }
+    _getMaxWidth() {
+        return this._notebookEditor.getLayoutInfo().width - 64;
+    }
+    _getDomWidth() {
+        return dom.getTotalWidth(this._domNode) - (NOTEBOOK_FIND_WIDGET_INITIAL_HORIZONTAL_PADDING * 2);
+    }
+    getCellToolbarActions(menu) {
+        const primary = [];
+        const secondary = [];
+        const result = { primary, secondary };
+        createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, result, g => /^inline/.test(g));
+        return result;
+    }
+    get inputValue() {
+        return this._findInput.getValue();
+    }
+    get replaceValue() {
+        return this._replaceInput.getValue();
+    }
+    get replacePattern() {
+        if (this._state.isRegex) {
+            return parseReplaceString(this.replaceValue);
+        }
+        return ReplacePattern.fromStaticValue(this.replaceValue);
+    }
+    get focusTracker() {
+        return this._focusTracker;
+    }
+    _onStateChanged(e) {
+        this._updateButtons();
+        this._updateMatchesCount();
+    }
+    _updateButtons() {
+        this._findInput.setEnabled(this._isVisible);
+        this._replaceInput.setEnabled(this._isVisible && this._isReplaceVisible);
+        const findInputIsNonEmpty = (this._state.searchString.length > 0);
+        this._replaceBtn.setEnabled(this._isVisible && this._isReplaceVisible && findInputIsNonEmpty);
+        this._replaceAllBtn.setEnabled(this._isVisible && this._isReplaceVisible && findInputIsNonEmpty);
+        this._domNode.classList.toggle('replaceToggled', this._isReplaceVisible);
+        this._toggleReplaceBtn.setExpanded(this._isReplaceVisible);
+        this.foundMatch = this._state.matchesCount > 0;
+        this.updateButtons(this.foundMatch);
+    }
+    _updateMatchesCount() {
+    }
+    dispose() {
+        super.dispose();
+        if (this._domNode && this._domNode.parentElement) {
+            this._domNode.parentElement.removeChild(this._domNode);
+        }
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    reveal(initialInput) {
+        if (initialInput) {
+            this._findInput.setValue(initialInput);
+        }
+        if (this._isVisible) {
+            this._findInput.select();
+            return;
+        }
+        this._isVisible = true;
+        this.updateButtons(this.foundMatch);
+        setTimeout(() => {
+            this._domNode.classList.add('visible', 'visible-transition');
+            this._domNode.setAttribute('aria-hidden', 'false');
+            this._findInput.select();
+        }, 0);
+    }
+    focus() {
+        this._findInput.focus();
+    }
+    show(initialInput, options) {
+        if (initialInput) {
+            this._findInput.setValue(initialInput);
+        }
+        this._isVisible = true;
+        setTimeout(() => {
+            this._domNode.classList.add('visible', 'visible-transition');
+            this._domNode.setAttribute('aria-hidden', 'false');
+            if (options?.focus ?? true) {
+                this.focus();
+            }
+        }, 0);
+    }
+    showWithReplace(initialInput, replaceInput) {
+        if (initialInput) {
+            this._findInput.setValue(initialInput);
+        }
+        if (replaceInput) {
+            this._replaceInput.setValue(replaceInput);
+        }
+        this._isVisible = true;
+        this._isReplaceVisible = true;
+        this._state.change({ isReplaceRevealed: this._isReplaceVisible }, false);
+        this._updateReplaceViewDisplay();
+        setTimeout(() => {
+            this._domNode.classList.add('visible', 'visible-transition');
+            this._domNode.setAttribute('aria-hidden', 'false');
+            this._updateButtons();
+            this._replaceInput.focus();
+        }, 0);
+    }
+    _updateReplaceViewDisplay() {
+        if (this._isReplaceVisible) {
+            this._innerReplaceDomNode.style.display = 'flex';
+        }
+        else {
+            this._innerReplaceDomNode.style.display = 'none';
+        }
+        this._replaceInput.width = dom.getTotalWidth(this._findInput.domNode);
+    }
+    hide() {
+        if (this._isVisible) {
+            this._domNode.classList.remove('visible-transition');
+            this._domNode.setAttribute('aria-hidden', 'true');
+            setTimeout(() => {
+                this._isVisible = false;
+                this.updateButtons(this.foundMatch);
+                this._domNode.classList.remove('visible');
+            }, 200);
+        }
+    }
+    _delayedUpdateHistory() {
+        this._updateHistoryDelayer.trigger(this._updateHistory.bind(this));
+    }
+    _updateHistory() {
+        this._findInput.inputBox.addToHistory();
+    }
+    _getRegexValue() {
+        return this._findInput.getRegex();
+    }
+    _getWholeWordValue() {
+        return this._findInput.getWholeWords();
+    }
+    _getCaseSensitiveValue() {
+        return this._findInput.getCaseSensitive();
+    }
+    updateButtons(foundMatch) {
+        const hasInput = this.inputValue.length > 0;
+        this.prevBtn.setEnabled(this._isVisible && hasInput && foundMatch);
+        this.nextBtn.setEnabled(this._isVisible && hasInput && foundMatch);
+    }
+};
+SimpleFindReplaceWidget = ( __decorate([
+    ( __param(0, IContextViewService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IInstantiationService))
+], SimpleFindReplaceWidget));
+registerThemingParticipant((theme, collector) => {
+    collector.addRule(`
+	.notebook-editor {
+		--notebook-find-width: ${NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH}px;
+		--notebook-find-horizontal-padding: ${NOTEBOOK_FIND_WIDGET_INITIAL_HORIZONTAL_PADDING}px;
+	}
+	`);
+});
+export { NotebookFindInput, NotebookFindInputFilterButton, SimpleFindReplaceWidget };