@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common 20.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/notebookVisibleCellObserver.js

@@ -0,0 +1,59 @@
+
+import { diffSets } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { cellRangesToIndexes } from '@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/notebook/common/notebookRange';
+
+class NotebookVisibleCellObserver extends Disposable {
+    get visibleCells() {
+        return this._visibleCells;
+    }
+    constructor(_notebookEditor) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._onDidChangeVisibleCells = this._register(( new Emitter()));
+        this.onDidChangeVisibleCells = this._onDidChangeVisibleCells.event;
+        this._viewModelDisposables = this._register(( new DisposableStore()));
+        this._visibleCells = [];
+        this._register(this._notebookEditor.onDidChangeVisibleRanges(this._updateVisibleCells, this));
+        this._register(this._notebookEditor.onDidChangeModel(this._onModelChange, this));
+        this._updateVisibleCells();
+    }
+    _onModelChange() {
+        this._viewModelDisposables.clear();
+        if (this._notebookEditor.hasModel()) {
+            this._viewModelDisposables.add(this._notebookEditor.onDidChangeViewCells(() => this.updateEverything()));
+        }
+        this.updateEverything();
+    }
+    updateEverything() {
+        this._onDidChangeVisibleCells.fire({ added: [], removed: Array.from(this._visibleCells) });
+        this._visibleCells = [];
+        this._updateVisibleCells();
+    }
+    _updateVisibleCells() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        const newVisibleCells = ( cellRangesToIndexes(this._notebookEditor.visibleRanges)
+            .map(index => this._notebookEditor.cellAt(index)))
+            .filter(isDefined);
+        const newVisibleHandles = ( new Set(( newVisibleCells.map(cell => cell.handle))));
+        const oldVisibleHandles = ( new Set(( this._visibleCells.map(cell => cell.handle))));
+        const diff = diffSets(oldVisibleHandles, newVisibleHandles);
+        const added = ( diff.added
+            .map(handle => this._notebookEditor.getCellByHandle(handle)))
+            .filter(isDefined);
+        const removed = ( diff.removed
+            .map(handle => this._notebookEditor.getCellByHandle(handle)))
+            .filter(isDefined);
+        this._visibleCells = newVisibleCells;
+        this._onDidChangeVisibleCells.fire({
+            added,
+            removed
+        });
+    }
+}
+
+export { NotebookVisibleCellObserver };

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

@@ -0,0 +1,69 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IContextViewService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { FindModel } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/contrib/find/findModel";
+import { SimpleFindReplaceWidget } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget";
+import { ICellViewModel, INotebookEditor, INotebookEditorContribution } from "@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { INotebookFindScope } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+export interface IShowNotebookFindWidgetOptions {
+    isRegex?: boolean;
+    wholeWord?: boolean;
+    matchCase?: boolean;
+    matchIndex?: number;
+    focus?: boolean;
+    searchStringSeededFrom?: {
+        cell: ICellViewModel;
+        range: Range;
+    };
+    findScope?: INotebookFindScope;
+}
+export declare class NotebookFindContrib extends Disposable implements INotebookEditorContribution {
+    private readonly notebookEditor;
+    private readonly instantiationService;
+    static readonly id: string;
+    private readonly _widget;
+    constructor(notebookEditor: INotebookEditor, instantiationService: IInstantiationService);
+    get widget(): NotebookFindWidget;
+    show(initialInput?: string, options?: IShowNotebookFindWidgetOptions): Promise<void>;
+    hide(): void;
+    replace(searchString: string | undefined): void;
+}
+declare class NotebookFindWidget extends SimpleFindReplaceWidget implements INotebookEditorContribution {
+    protected _findWidgetFocused: IContextKey<boolean>;
+    private _isFocused;
+    private _showTimeout;
+    private _hideTimeout;
+    private _previousFocusElement?;
+    private _findModel;
+    constructor(_notebookEditor: INotebookEditor, contextViewService: IContextViewService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, contextMenuService: IContextMenuService, hoverService: IHoverService, instantiationService: IInstantiationService, storageService: IStorageService);
+    get findModel(): FindModel;
+    get isFocused(): boolean;
+    private _onFindInputKeyDown;
+    private _onReplaceInputKeyDown;
+    protected onInputChanged(): boolean;
+    private findIndex;
+    protected find(previous: boolean): void;
+    protected replaceOne(): void;
+    protected replaceAll(): void;
+    protected findFirst(): void;
+    protected onFocusTrackerFocus(): void;
+    protected onFocusTrackerBlur(): void;
+    protected onReplaceInputFocusTrackerFocus(): void;
+    protected onReplaceInputFocusTrackerBlur(): void;
+    protected onFindInputFocusTrackerFocus(): void;
+    protected onFindInputFocusTrackerBlur(): void;
+    show(initialInput?: string, options?: IShowNotebookFindWidgetOptions): Promise<void>;
+    replace(initialFindInput?: string, initialReplaceInput?: string): void;
+    hide(): void;
+    protected _updateMatchesCount(): void;
+    private _getAriaLabel;
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,318 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, addDisposableListener, EventType, isHTMLElement, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { KeyCode, KeyMod } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { format } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { MATCHES_LIMIT } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/find/browser/findModel';
+import { FindReplaceState } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/find/browser/findState';
+import { NLS_MATCHES_LOCATION, NLS_NO_RESULTS } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/find/browser/findWidget';
+import { FindWidgetSearchHistory } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/find/browser/findWidgetSearchHistory';
+import { ReplaceWidgetHistory } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/find/browser/replaceWidgetHistory';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextViewService, IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { FindModel } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/contrib/find/findModel';
+import { SimpleFindReplaceWidget } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget';
+import { CellEditState } from '@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED } from '@codingame/monaco-vscode-eda30bac-0984-5b42-9362-c68996b85232-common/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))
+        ));
+    }
+    get widget() {
+        return this._widget.value;
+    }
+    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, hoverService, instantiationService, storageService) {
+        const findSearchHistory = FindWidgetSearchHistory.getOrCreate(storageService);
+        const replaceHistory = ReplaceWidgetHistory.getOrCreate(storageService);
+        super(contextViewService, contextKeyService, configurationService, contextMenuService, instantiationService, hoverService, ( new FindReplaceState()), _notebookEditor, findSearchHistory, replaceHistory);
+        this._isFocused = false;
+        this._showTimeout = null;
+        this._hideTimeout = null;
+        this._findModel = ( new FindModel(this._notebookEditor, this._state, this._configurationService));
+        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(addDisposableListener(this.getDomNode(), EventType.FOCUS, e => {
+            this._previousFocusElement = isHTMLElement(e.relatedTarget) ? e.relatedTarget : undefined;
+        }, true));
+    }
+    get findModel() {
+        return this._findModel;
+    }
+    get isFocused() {
+        return this._isFocused;
+    }
+    _onFindInputKeyDown(e) {
+        if (e.equals(KeyCode.Enter)) {
+            this.find(false);
+            e.preventDefault();
+            return;
+        }
+        else if (e.equals(KeyMod.Shift | KeyCode.Enter)) {
+            this.find(true);
+            e.preventDefault();
+            return;
+        }
+    }
+    _onReplaceInputKeyDown(e) {
+        if (e.equals(KeyCode.Enter)) {
+            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);
+        this._isFocused = true;
+    }
+    onFocusTrackerBlur() {
+        this._previousFocusElement = undefined;
+        this._findWidgetFocused.reset();
+        this._isFocused = false;
+    }
+    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) {
+                getWindow(this.getDomNode()).clearTimeout(this._hideTimeout);
+                this._hideTimeout = null;
+                this._notebookEditor.removeClassName(FIND_HIDE_TRANSITION);
+            }
+            this._notebookEditor.addClassName(FIND_SHOW_TRANSITION);
+            this._showTimeout = 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) {
+                getWindow(this.getDomNode()).clearTimeout(this._hideTimeout);
+                this._hideTimeout = null;
+                this._notebookEditor.removeClassName(FIND_HIDE_TRANSITION);
+            }
+            this._notebookEditor.addClassName(FIND_SHOW_TRANSITION);
+            this._showTimeout = 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) {
+                getWindow(this.getDomNode()).clearTimeout(this._showTimeout);
+                this._showTimeout = null;
+                this._notebookEditor.removeClassName(FIND_SHOW_TRANSITION);
+            }
+            this._notebookEditor.addClassName(FIND_HIDE_TRANSITION);
+            this._hideTimeout = 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.minWidth = MAX_MATCHES_COUNT_WIDTH + 'px';
+        this._matchesCount.title = '';
+        this._matchesCount.firstChild?.remove();
+        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 = 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 === ''
+                ? ( localize(8589, "{0} found", label))
+                : ( localize(8590, "{0} found for '{1}'", label, searchString));
+        }
+        return localize(8591, "{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, IHoverService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IStorageService))
+], NotebookFindWidget));
+
+export { NotebookFindContrib };