@codingame/monaco-vscode-notebook-service-override 1.85.1

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

@@ -0,0 +1,168 @@
+import './media/notebookFind.css.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { StartFindAction, StartFindReplaceAction, getSelectionSearchString } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findController.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { NotebookFindContrib } from './notebookFindWidget.js';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NOTEBOOK_EDITOR_FOCUSED, KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED, NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+registerNotebookContribution(NotebookFindContrib.id, NotebookFindContrib);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.hideFind',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/find/notebookFind',
+                'notebookActions.hideFind',
+                "Hide Find in Notebook"
+            )), original: 'Hide Find in Notebook' },
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED)),
+                primary: 9 ,
+                weight: 200
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(NotebookFindContrib.id);
+        controller.hide();
+        editor.focus();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.find',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/find/notebookFind',
+                'notebookActions.findInNotebook',
+                "Find in Notebook"
+            )), original: 'Find in Notebook' },
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( ContextKeyExpr.or(NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR)), ( EditorContextKeys.focus.toNegated()))),
+                primary: 36  | 2048 ,
+                weight: 200
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(NotebookFindContrib.id);
+        controller.show();
+    }
+});
+function notebookContainsTextModel(uri, textModel) {
+    if (textModel.uri.scheme === Schemas.vscodeNotebookCell) {
+        const cellUri = CellUri.parse(textModel.uri);
+        if (cellUri && isEqual(cellUri.notebook, uri)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getSearchStringOptions(editor, opts) {
+    if (opts.seedSearchStringFromSelection === 'single') {
+        const selectionSearchString = getSelectionSearchString(editor, opts.seedSearchStringFromSelection, opts.seedSearchStringFromNonEmptySelection);
+        if (selectionSearchString) {
+            return {
+                searchString: selectionSearchString,
+                selection: editor.getSelection()
+            };
+        }
+    }
+    else if (opts.seedSearchStringFromSelection === 'multiple' && !opts.updateSearchScope) {
+        const selectionSearchString = getSelectionSearchString(editor, opts.seedSearchStringFromSelection);
+        if (selectionSearchString) {
+            return {
+                searchString: selectionSearchString,
+                selection: editor.getSelection()
+            };
+        }
+    }
+    return undefined;
+}
+StartFindAction.addImplementation(100, (accessor, codeEditor, args) => {
+    const editorService = accessor.get(IEditorService);
+    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    if (!editor) {
+        return false;
+    }
+    if (!codeEditor.hasModel()) {
+        return false;
+    }
+    if (!editor.hasEditorFocus() && !editor.hasWebviewFocus()) {
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const textEditor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
+        if (editor.hasModel() && textEditor && textEditor.hasModel() && notebookContainsTextModel(editor.textModel.uri, textEditor.getModel())) ;
+        else {
+            return false;
+        }
+    }
+    const controller = editor.getContribution(NotebookFindContrib.id);
+    const searchStringOptions = getSearchStringOptions(codeEditor, {
+        forceRevealReplace: false,
+        seedSearchStringFromSelection: codeEditor.getOption(41 ).seedSearchStringFromSelection !== 'never' ? 'single' : 'none',
+        seedSearchStringFromNonEmptySelection: codeEditor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+        seedSearchStringFromGlobalClipboard: codeEditor.getOption(41 ).globalFindClipboard,
+        shouldFocus: 1 ,
+        shouldAnimate: true,
+        updateSearchScope: false,
+        loop: codeEditor.getOption(41 ).loop
+    });
+    let options = undefined;
+    const uri = codeEditor.getModel().uri;
+    const data = CellUri.parse(uri);
+    if (searchStringOptions?.selection && data) {
+        const cell = editor.getCellByHandle(data.handle);
+        if (cell) {
+            options = {
+                searchStringSeededFrom: { cell, range: searchStringOptions.selection },
+            };
+        }
+    }
+    controller.show(searchStringOptions?.searchString, options);
+    return true;
+});
+StartFindReplaceAction.addImplementation(100, (accessor, codeEditor, args) => {
+    const editorService = accessor.get(IEditorService);
+    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    if (!editor) {
+        return false;
+    }
+    if (!codeEditor.hasModel()) {
+        return false;
+    }
+    const controller = editor.getContribution(NotebookFindContrib.id);
+    const searchStringOptions = getSearchStringOptions(codeEditor, {
+        forceRevealReplace: false,
+        seedSearchStringFromSelection: codeEditor.getOption(41 ).seedSearchStringFromSelection !== 'never' ? 'single' : 'none',
+        seedSearchStringFromNonEmptySelection: codeEditor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+        seedSearchStringFromGlobalClipboard: codeEditor.getOption(41 ).globalFindClipboard,
+        shouldFocus: 1 ,
+        shouldAnimate: true,
+        updateSearchScope: false,
+        loop: codeEditor.getOption(41 ).loop
+    });
+    if (controller) {
+        controller.replace(searchStringOptions?.searchString);
+        return true;
+    }
+    return false;
+});

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

@@ -0,0 +1,317 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { MATCHES_LIMIT } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findModel.js';
+import { FindReplaceState } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findState.js';
+import { NLS_MATCHES_LOCATION, NLS_NO_RESULTS } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findWidget.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { FindModel } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/contrib/find/findModel';
+import { SimpleFindReplaceWidget } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget';
+import { CellEditState } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+
+const FIND_HIDE_TRANSITION = 'find-hide-transition';
+const FIND_SHOW_TRANSITION = 'find-show-transition';
+let MAX_MATCHES_COUNT_WIDTH = 69;
+const PROGRESS_BAR_DELAY = 200;
+let NotebookFindContrib = class NotebookFindContrib extends Disposable {
+    static { this.id = 'workbench.notebook.find'; }
+    constructor(notebookEditor, instantiationService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.instantiationService = instantiationService;
+        this.widget = ( new Lazy(
+            () => this._register(this.instantiationService.createInstance(NotebookFindWidget, this.notebookEditor))
+        ));
+    }
+    show(initialInput, options) {
+        return this.widget.value.show(initialInput, options);
+    }
+    hide() {
+        this.widget.rawValue?.hide();
+    }
+    replace(searchString) {
+        return this.widget.value.replace(searchString);
+    }
+};
+NotebookFindContrib = ( __decorate([
+    ( __param(1, IInstantiationService))
+], NotebookFindContrib));
+let NotebookFindWidget = class NotebookFindWidget extends SimpleFindReplaceWidget {
+    constructor(_notebookEditor, contextViewService, contextKeyService, configurationService, contextMenuService, menuService, instantiationService) {
+        super(contextViewService, contextKeyService, configurationService, contextMenuService, instantiationService, ( new FindReplaceState()), _notebookEditor);
+        this._showTimeout = null;
+        this._hideTimeout = null;
+        this._findModel = ( new FindModel(this._notebookEditor, this._state, this._configurationService));
+        dom.append(this._notebookEditor.getDomNode(), this.getDomNode());
+        this._findWidgetFocused = KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED.bindTo(contextKeyService);
+        this._register(this._findInput.onKeyDown((e) => this._onFindInputKeyDown(e)));
+        this._register(this._replaceInput.onKeyDown((e) => this._onReplaceInputKeyDown(e)));
+        this._register(this._state.onFindReplaceStateChange((e) => {
+            this.onInputChanged();
+            if (e.isSearching) {
+                if (this._state.isSearching) {
+                    this._progressBar.infinite().show(PROGRESS_BAR_DELAY);
+                }
+                else {
+                    this._progressBar.stop().hide();
+                }
+            }
+            if (this._findModel.currentMatch >= 0) {
+                const currentMatch = this._findModel.getCurrentMatch();
+                this._replaceBtn.setEnabled(currentMatch.isModelMatch);
+            }
+            const matches = this._findModel.findMatches;
+            this._replaceAllBtn.setEnabled(matches.length > 0 && matches.find(match => match.webviewMatches.length > 0) === undefined);
+            if (e.filters) {
+                this._findInput.updateFilterState(this._state.filters?.isModified() ?? false);
+            }
+        }));
+        this._register(dom.addDisposableListener(this.getDomNode(), dom.EventType.FOCUS, e => {
+            this._previousFocusElement = e.relatedTarget instanceof HTMLElement ? e.relatedTarget : undefined;
+        }, true));
+    }
+    _onFindInputKeyDown(e) {
+        if (e.equals(3 )) {
+            this.find(false);
+            e.preventDefault();
+            return;
+        }
+        else if (e.equals(1024  | 3 )) {
+            this.find(true);
+            e.preventDefault();
+            return;
+        }
+    }
+    _onReplaceInputKeyDown(e) {
+        if (e.equals(3 )) {
+            this.replaceOne();
+            e.preventDefault();
+            return;
+        }
+    }
+    onInputChanged() {
+        this._state.change({ searchString: this.inputValue }, false);
+        const findMatches = this._findModel.findMatches;
+        if (findMatches && findMatches.length) {
+            return true;
+        }
+        return false;
+    }
+    findIndex(index) {
+        this._findModel.find({ index });
+    }
+    find(previous) {
+        this._findModel.find({ previous });
+    }
+    replaceOne() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        if (!this._findModel.findMatches.length) {
+            return;
+        }
+        this._findModel.ensureFindMatches();
+        if (this._findModel.currentMatch < 0) {
+            this._findModel.find({ previous: false });
+        }
+        const currentMatch = this._findModel.getCurrentMatch();
+        const cell = currentMatch.cell;
+        if (currentMatch.isModelMatch) {
+            const match = currentMatch.match;
+            this._progressBar.infinite().show(PROGRESS_BAR_DELAY);
+            const replacePattern = this.replacePattern;
+            const replaceString = replacePattern.buildReplaceString(match.matches, this._state.preserveCase);
+            const viewModel = this._notebookEditor.getViewModel();
+            viewModel.replaceOne(cell, match.range, replaceString).then(() => {
+                this._progressBar.stop();
+            });
+        }
+        else {
+            console.error('Replace does not work for output match');
+        }
+    }
+    replaceAll() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        this._progressBar.infinite().show(PROGRESS_BAR_DELAY);
+        const replacePattern = this.replacePattern;
+        const cellFindMatches = this._findModel.findMatches;
+        const replaceStrings = [];
+        cellFindMatches.forEach(cellFindMatch => {
+            cellFindMatch.contentMatches.forEach(match => {
+                const matches = match.matches;
+                replaceStrings.push(replacePattern.buildReplaceString(matches, this._state.preserveCase));
+            });
+        });
+        const viewModel = this._notebookEditor.getViewModel();
+        viewModel.replaceAll(this._findModel.findMatches, replaceStrings).then(() => {
+            this._progressBar.stop();
+        });
+    }
+    findFirst() { }
+    onFocusTrackerFocus() {
+        this._findWidgetFocused.set(true);
+    }
+    onFocusTrackerBlur() {
+        this._previousFocusElement = undefined;
+        this._findWidgetFocused.reset();
+    }
+    onReplaceInputFocusTrackerFocus() {
+    }
+    onReplaceInputFocusTrackerBlur() {
+    }
+    onFindInputFocusTrackerFocus() { }
+    onFindInputFocusTrackerBlur() { }
+    async show(initialInput, options) {
+        const searchStringUpdate = this._state.searchString !== initialInput;
+        super.show(initialInput, options);
+        this._state.change({ searchString: initialInput ?? this._state.searchString, isRevealed: true }, false);
+        if (typeof options?.matchIndex === 'number') {
+            if (!this._findModel.findMatches.length) {
+                await this._findModel.research();
+            }
+            this.findIndex(options.matchIndex);
+        }
+        else {
+            this._findInput.select();
+        }
+        if (!searchStringUpdate && options?.searchStringSeededFrom) {
+            this._findModel.refreshCurrentMatch(options.searchStringSeededFrom);
+        }
+        if (this._showTimeout === null) {
+            if (this._hideTimeout !== null) {
+                dom.getWindow(this.getDomNode()).clearTimeout(this._hideTimeout);
+                this._hideTimeout = null;
+                this._notebookEditor.removeClassName(FIND_HIDE_TRANSITION);
+            }
+            this._notebookEditor.addClassName(FIND_SHOW_TRANSITION);
+            this._showTimeout = dom.getWindow(this.getDomNode()).setTimeout(() => {
+                this._notebookEditor.removeClassName(FIND_SHOW_TRANSITION);
+                this._showTimeout = null;
+            }, 200);
+        }
+    }
+    replace(initialFindInput, initialReplaceInput) {
+        super.showWithReplace(initialFindInput, initialReplaceInput);
+        this._state.change({ searchString: initialFindInput ?? '', replaceString: initialReplaceInput ?? '', isRevealed: true }, false);
+        this._replaceInput.select();
+        if (this._showTimeout === null) {
+            if (this._hideTimeout !== null) {
+                dom.getWindow(this.getDomNode()).clearTimeout(this._hideTimeout);
+                this._hideTimeout = null;
+                this._notebookEditor.removeClassName(FIND_HIDE_TRANSITION);
+            }
+            this._notebookEditor.addClassName(FIND_SHOW_TRANSITION);
+            this._showTimeout = dom.getWindow(this.getDomNode()).setTimeout(() => {
+                this._notebookEditor.removeClassName(FIND_SHOW_TRANSITION);
+                this._showTimeout = null;
+            }, 200);
+        }
+    }
+    hide() {
+        super.hide();
+        this._state.change({ isRevealed: false }, false);
+        this._findModel.clear();
+        this._notebookEditor.findStop();
+        this._progressBar.stop();
+        if (this._hideTimeout === null) {
+            if (this._showTimeout !== null) {
+                dom.getWindow(this.getDomNode()).clearTimeout(this._showTimeout);
+                this._showTimeout = null;
+                this._notebookEditor.removeClassName(FIND_SHOW_TRANSITION);
+            }
+            this._notebookEditor.addClassName(FIND_HIDE_TRANSITION);
+            this._hideTimeout = dom.getWindow(this.getDomNode()).setTimeout(() => {
+                this._notebookEditor.removeClassName(FIND_HIDE_TRANSITION);
+            }, 200);
+        }
+        if (this._previousFocusElement && this._previousFocusElement.offsetParent) {
+            this._previousFocusElement.focus();
+            this._previousFocusElement = undefined;
+        }
+        if (this._notebookEditor.hasModel()) {
+            for (let i = 0; i < this._notebookEditor.getLength(); i++) {
+                const cell = this._notebookEditor.cellAt(i);
+                if (cell.getEditState() === CellEditState.Editing && cell.editStateSource === 'find') {
+                    cell.updateEditState(CellEditState.Preview, 'closeFind');
+                }
+            }
+        }
+    }
+    _updateMatchesCount() {
+        if (!this._findModel || !this._findModel.findMatches) {
+            return;
+        }
+        this._matchesCount.style.width = MAX_MATCHES_COUNT_WIDTH + 'px';
+        this._matchesCount.title = '';
+        if (this._matchesCount.firstChild) {
+            this._matchesCount.removeChild(this._matchesCount.firstChild);
+        }
+        let label;
+        if (this._state.matchesCount > 0) {
+            let matchesCount = String(this._state.matchesCount);
+            if (this._state.matchesCount >= MATCHES_LIMIT) {
+                matchesCount += '+';
+            }
+            const matchesPosition = this._findModel.currentMatch < 0 ? '?' : String((this._findModel.currentMatch + 1));
+            label = strings.format(NLS_MATCHES_LOCATION, matchesPosition, matchesCount);
+        }
+        else {
+            label = NLS_NO_RESULTS;
+        }
+        this._matchesCount.appendChild(document.createTextNode(label));
+        alert(this._getAriaLabel(label, this._state.currentMatch, this._state.searchString));
+        MAX_MATCHES_COUNT_WIDTH = Math.max(MAX_MATCHES_COUNT_WIDTH, this._matchesCount.clientWidth);
+    }
+    _getAriaLabel(label, currentMatch, searchString) {
+        if (label === NLS_NO_RESULTS) {
+            return searchString === ''
+                ? ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget',
+                'ariaSearchNoResultEmpty',
+                "{0} found",
+                label
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget',
+                'ariaSearchNoResult',
+                "{0} found for '{1}'",
+                label,
+                searchString
+            ));
+        }
+        return ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget',
+            'ariaSearchNoResultWithLineNumNoCurrentMatch',
+            "{0} found for '{1}'",
+            label,
+            searchString
+        ));
+    }
+    dispose() {
+        this._notebookEditor?.removeClassName(FIND_SHOW_TRANSITION);
+        this._notebookEditor?.removeClassName(FIND_HIDE_TRANSITION);
+        this._findModel.dispose();
+        super.dispose();
+    }
+};
+NotebookFindWidget = ( __decorate([
+    ( __param(1, IContextViewService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IMenuService)),
+    ( __param(6, IInstantiationService))
+], NotebookFindWidget));
+
+export { NotebookFindContrib };