@codingame/monaco-vscode-api 1.85.0 → 1.85.2

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

@@ -0,0 +1,416 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Delayer, createCancelablePromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CellEditState } from '../../notebookBrowser.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { PrefixSumComputer } from 'monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js';
+import { CellKind, NotebookCellsChangeType } from '../../../common/notebookCommon.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { findFirstIdxMonotonousOrArrLen } from 'monaco-editor/esm/vs/base/common/arraysFind.js';
+import { FindMatchDecorationModel } from './findMatchDecorationModel.js';
+class CellFindMatchModel {
+    get length() {
+        return this._contentMatches.length + this._webviewMatches.length;
+    }
+    get contentMatches() {
+        return this._contentMatches;
+    }
+    get webviewMatches() {
+        return this._webviewMatches;
+    }
+    constructor(cell, index, contentMatches, webviewMatches) {
+        this.cell = cell;
+        this.index = index;
+        this._contentMatches = contentMatches;
+        this._webviewMatches = webviewMatches;
+    }
+    getMatch(index) {
+        if (index >= this.length) {
+            throw new Error('NotebookCellFindMatch: index out of range');
+        }
+        if (index < this._contentMatches.length) {
+            return this._contentMatches[index];
+        }
+        return this._webviewMatches[index - this._contentMatches.length];
+    }
+}
+let FindModel = class FindModel extends Disposable {
+    get findMatches() {
+        return this._findMatches;
+    }
+    get currentMatch() {
+        return this._currentMatch;
+    }
+    constructor(_notebookEditor, _state, _configurationService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._state = _state;
+        this._configurationService = _configurationService;
+        this._findMatches = [];
+        this._findMatchesStarts = null;
+        this._currentMatch = -1;
+        this._computePromise = null;
+        this._modelDisposable = this._register(( new DisposableStore()));
+        this._throttledDelayer = ( new Delayer(20));
+        this._computePromise = null;
+        this._register(_state.onFindReplaceStateChange(e => {
+            this._updateCellStates(e);
+            if (e.searchString || e.isRegex || e.matchCase || e.searchScope || e.wholeWord || (e.isRevealed && this._state.isRevealed) || e.filters || e.isReplaceRevealed) {
+                this.research();
+            }
+            if (e.isRevealed && !this._state.isRevealed) {
+                this.clear();
+            }
+        }));
+        this._register(this._notebookEditor.onDidChangeModel(e => {
+            this._registerModelListener(e);
+        }));
+        this._register(this._notebookEditor.onDidChangeCellState(e => {
+            if (e.cell.cellKind === CellKind.Markup && e.source.editStateChanged) {
+                this.research();
+            }
+        }));
+        if (this._notebookEditor.hasModel()) {
+            this._registerModelListener(this._notebookEditor.textModel);
+        }
+        this._findMatchDecorationModel = ( new FindMatchDecorationModel(this._notebookEditor, this._notebookEditor.getId()));
+    }
+    _updateCellStates(e) {
+        if (!this._state.filters?.markupInput) {
+            return;
+        }
+        if (!this._state.filters?.markupPreview) {
+            return;
+        }
+        const updateEditingState = () => {
+            const viewModel = this._notebookEditor.getViewModel();
+            if (!viewModel) {
+                return;
+            }
+            const wordSeparators = this._configurationService.inspect('editor.wordSeparators').value;
+            const options = {
+                regex: this._state.isRegex,
+                wholeWord: this._state.wholeWord,
+                caseSensitive: this._state.matchCase,
+                wordSeparators: wordSeparators,
+                includeMarkupInput: true,
+                includeCodeInput: false,
+                includeMarkupPreview: false,
+                includeOutput: false
+            };
+            const contentMatches = viewModel.find(this._state.searchString, options);
+            for (let i = 0; i < viewModel.length; i++) {
+                const cell = viewModel.cellAt(i);
+                if (cell && cell.cellKind === CellKind.Markup) {
+                    const foundContentMatch = contentMatches.find(m => m.cell.handle === cell.handle && m.contentMatches.length > 0);
+                    const targetState = foundContentMatch ? CellEditState.Editing : CellEditState.Preview;
+                    const currentEditingState = cell.getEditState();
+                    if (currentEditingState === CellEditState.Editing && cell.editStateSource !== 'find') {
+                        continue;
+                    }
+                    if (currentEditingState !== targetState) {
+                        cell.updateEditState(targetState, 'find');
+                    }
+                }
+            }
+        };
+        if (e.isReplaceRevealed && !this._state.isReplaceRevealed) {
+            const viewModel = this._notebookEditor.getViewModel();
+            if (!viewModel) {
+                return;
+            }
+            for (let i = 0; i < viewModel.length; i++) {
+                const cell = viewModel.cellAt(i);
+                if (cell && cell.cellKind === CellKind.Markup) {
+                    if (cell.getEditState() === CellEditState.Editing && cell.editStateSource === 'find') {
+                        cell.updateEditState(CellEditState.Preview, 'find');
+                    }
+                }
+            }
+            return;
+        }
+        if (e.isReplaceRevealed) {
+            updateEditingState();
+        }
+        else if ((e.filters || e.isRevealed || e.searchString || e.replaceString) && this._state.isRevealed && this._state.isReplaceRevealed) {
+            updateEditingState();
+        }
+    }
+    ensureFindMatches() {
+        if (!this._findMatchesStarts) {
+            this.set(this._findMatches, true);
+        }
+    }
+    getCurrentMatch() {
+        const nextIndex = this._findMatchesStarts.getIndexOf(this._currentMatch);
+        const cell = this._findMatches[nextIndex.index].cell;
+        const match = this._findMatches[nextIndex.index].getMatch(nextIndex.remainder);
+        return {
+            cell,
+            match,
+            isModelMatch: nextIndex.remainder < this._findMatches[nextIndex.index].contentMatches.length
+        };
+    }
+    refreshCurrentMatch(focus) {
+        const findMatchIndex = this.findMatches.findIndex(match => match.cell === focus.cell);
+        if (findMatchIndex === -1) {
+            return;
+        }
+        const findMatch = this.findMatches[findMatchIndex];
+        const index = findMatch.contentMatches.findIndex(match => match.range.intersectRanges(focus.range) !== null);
+        if (index === undefined) {
+            return;
+        }
+        const matchesBefore = findMatchIndex === 0 ? 0 : (this._findMatchesStarts?.getPrefixSum(findMatchIndex - 1) ?? 0);
+        this._currentMatch = matchesBefore + index;
+        this.highlightCurrentFindMatchDecoration(findMatchIndex, index).then(offset => {
+            this.revealCellRange(findMatchIndex, index, offset);
+            this._state.changeMatchInfo(this._currentMatch, this._findMatches.reduce((p, c) => p + c.length, 0), undefined);
+        });
+    }
+    find(option) {
+        if (!this.findMatches.length) {
+            return;
+        }
+        if (!this._findMatchesStarts) {
+            this.set(this._findMatches, true);
+            if ('index' in option) {
+                this._currentMatch = option.index;
+            }
+        }
+        else {
+            const totalVal = this._findMatchesStarts.getTotalSum();
+            if ('index' in option) {
+                this._currentMatch = option.index;
+            }
+            else if (this._currentMatch === -1) {
+                this._currentMatch = option.previous ? totalVal - 1 : 0;
+            }
+            else {
+                const nextVal = (this._currentMatch + (option.previous ? -1 : 1) + totalVal) % totalVal;
+                this._currentMatch = nextVal;
+            }
+        }
+        const nextIndex = this._findMatchesStarts.getIndexOf(this._currentMatch);
+        this.highlightCurrentFindMatchDecoration(nextIndex.index, nextIndex.remainder).then(offset => {
+            this.revealCellRange(nextIndex.index, nextIndex.remainder, offset);
+            this._state.changeMatchInfo(this._currentMatch, this._findMatches.reduce((p, c) => p + c.length, 0), undefined);
+        });
+    }
+    revealCellRange(cellIndex, matchIndex, outputOffset) {
+        const findMatch = this._findMatches[cellIndex];
+        if (matchIndex >= findMatch.contentMatches.length) {
+            this._notebookEditor.focusElement(findMatch.cell);
+            const index = this._notebookEditor.getCellIndex(findMatch.cell);
+            if (index !== undefined) {
+                this._notebookEditor.revealCellOffsetInCenter(findMatch.cell, outputOffset ?? 0);
+            }
+        }
+        else {
+            const match = findMatch.getMatch(matchIndex);
+            if (findMatch.cell.getEditState() !== CellEditState.Editing) {
+                findMatch.cell.updateEditState(CellEditState.Editing, 'find');
+            }
+            findMatch.cell.isInputCollapsed = false;
+            this._notebookEditor.focusElement(findMatch.cell);
+            this._notebookEditor.setCellEditorSelection(findMatch.cell, match.range);
+            this._notebookEditor.revealRangeInCenterIfOutsideViewportAsync(findMatch.cell, match.range);
+        }
+    }
+    _registerModelListener(notebookTextModel) {
+        this._modelDisposable.clear();
+        if (notebookTextModel) {
+            this._modelDisposable.add(notebookTextModel.onDidChangeContent((e) => {
+                if (!( e.rawEvents.some(
+                    event => event.kind === NotebookCellsChangeType.ChangeCellContent || event.kind === NotebookCellsChangeType.ModelChange
+                ))) {
+                    return;
+                }
+                this.research();
+            }));
+        }
+        this.research();
+    }
+    async research() {
+        return this._throttledDelayer.trigger(async () => {
+            this._state.change({ isSearching: true }, false);
+            await this._research();
+            this._state.change({ isSearching: false }, false);
+        });
+    }
+    async _research() {
+        this._computePromise?.cancel();
+        if (!this._state.isRevealed || !this._notebookEditor.hasModel()) {
+            this.set([], false);
+            return;
+        }
+        this._computePromise = createCancelablePromise(token => this._compute(token));
+        const findMatches = await this._computePromise;
+        if (!findMatches) {
+            this.set([], false);
+            return;
+        }
+        if (findMatches.length === 0) {
+            this.set([], false);
+            return;
+        }
+        const findFirstMatchAfterCellIndex = (cellIndex) => {
+            const matchAfterSelection = findFirstIdxMonotonousOrArrLen(( findMatches.map(match => match.index)), index => index >= cellIndex);
+            this._updateCurrentMatch(findMatches, this._matchesCountBeforeIndex(findMatches, matchAfterSelection));
+        };
+        if (this._currentMatch === -1) {
+            if (this._notebookEditor.getLength() === 0) {
+                this.set(findMatches, false);
+                return;
+            }
+            else {
+                const focus = this._notebookEditor.getFocus().start;
+                findFirstMatchAfterCellIndex(focus);
+                this.set(findMatches, false);
+                return;
+            }
+        }
+        const oldCurrIndex = this._findMatchesStarts.getIndexOf(this._currentMatch);
+        const oldCurrCell = this._findMatches[oldCurrIndex.index].cell;
+        const oldCurrMatchCellIndex = this._notebookEditor.getCellIndex(oldCurrCell);
+        if (oldCurrMatchCellIndex < 0) {
+            if (this._notebookEditor.getLength() === 0) {
+                this.set(findMatches, false);
+                return;
+            }
+            findFirstMatchAfterCellIndex(oldCurrMatchCellIndex);
+            return;
+        }
+        const cell = this._notebookEditor.cellAt(oldCurrMatchCellIndex);
+        if (cell.cellKind === CellKind.Markup && cell.getEditState() === CellEditState.Preview) {
+            findFirstMatchAfterCellIndex(oldCurrMatchCellIndex);
+            return;
+        }
+        if (!this._findMatchDecorationModel.currentMatchDecorations) {
+            findFirstMatchAfterCellIndex(oldCurrMatchCellIndex);
+            return;
+        }
+        if (this._findMatchDecorationModel.currentMatchDecorations.kind === 'input') {
+            const currentMatchDecorationId = this._findMatchDecorationModel.currentMatchDecorations.decorations.find(decoration => decoration.ownerId === cell.handle);
+            if (!currentMatchDecorationId) {
+                findFirstMatchAfterCellIndex(oldCurrMatchCellIndex);
+                return;
+            }
+            const matchAfterSelection = findFirstIdxMonotonousOrArrLen(findMatches, match => match.index >= oldCurrMatchCellIndex) % findMatches.length;
+            if (findMatches[matchAfterSelection].index > oldCurrMatchCellIndex) {
+                this._updateCurrentMatch(findMatches, this._matchesCountBeforeIndex(findMatches, matchAfterSelection));
+                return;
+            }
+            else {
+                let currMatchRangeInEditor = cell.editorAttached && currentMatchDecorationId.decorations[0] ? cell.getCellDecorationRange(currentMatchDecorationId.decorations[0]) : null;
+                if (currMatchRangeInEditor === null && oldCurrIndex.remainder < this._findMatches[oldCurrIndex.index].contentMatches.length) {
+                    currMatchRangeInEditor = this._findMatches[oldCurrIndex.index].getMatch(oldCurrIndex.remainder).range;
+                }
+                if (currMatchRangeInEditor !== null) {
+                    const cellMatch = findMatches[matchAfterSelection];
+                    const matchAfterOldSelection = findFirstIdxMonotonousOrArrLen(cellMatch.contentMatches, match => Range.compareRangesUsingStarts(match.range, currMatchRangeInEditor) >= 0);
+                    this._updateCurrentMatch(findMatches, this._matchesCountBeforeIndex(findMatches, matchAfterSelection) + matchAfterOldSelection);
+                }
+                else {
+                    this._updateCurrentMatch(findMatches, this._matchesCountBeforeIndex(findMatches, matchAfterSelection));
+                    return;
+                }
+            }
+        }
+        else {
+            const matchAfterSelection = findFirstIdxMonotonousOrArrLen(( findMatches.map(match => match.index)), index => index >= oldCurrMatchCellIndex) % findMatches.length;
+            this._updateCurrentMatch(findMatches, this._matchesCountBeforeIndex(findMatches, matchAfterSelection));
+        }
+    }
+    set(cellFindMatches, autoStart) {
+        if (!cellFindMatches || !cellFindMatches.length) {
+            this._findMatches = [];
+            this._findMatchDecorationModel.setAllFindMatchesDecorations([]);
+            this.constructFindMatchesStarts();
+            this._currentMatch = -1;
+            this._findMatchDecorationModel.clearCurrentFindMatchDecoration();
+            this._state.changeMatchInfo(this._currentMatch, this._findMatches.reduce((p, c) => p + c.length, 0), undefined);
+            return;
+        }
+        this._findMatches = cellFindMatches;
+        this._findMatchDecorationModel.setAllFindMatchesDecorations(cellFindMatches || []);
+        this.constructFindMatchesStarts();
+        if (autoStart) {
+            this._currentMatch = 0;
+            this.highlightCurrentFindMatchDecoration(0, 0);
+        }
+        this._state.changeMatchInfo(this._currentMatch, this._findMatches.reduce((p, c) => p + c.length, 0), undefined);
+    }
+    async _compute(token) {
+        if (!this._notebookEditor.hasModel()) {
+            return null;
+        }
+        let ret = null;
+        const val = this._state.searchString;
+        const wordSeparators = this._configurationService.inspect('editor.wordSeparators').value;
+        const options = {
+            regex: this._state.isRegex,
+            wholeWord: this._state.wholeWord,
+            caseSensitive: this._state.matchCase,
+            wordSeparators: wordSeparators,
+            includeMarkupInput: this._state.filters?.markupInput ?? true,
+            includeCodeInput: this._state.filters?.codeInput ?? true,
+            includeMarkupPreview: !!this._state.filters?.markupPreview,
+            includeOutput: !!this._state.filters?.codeOutput
+        };
+        ret = await this._notebookEditor.find(val, options, token);
+        if (token.isCancellationRequested) {
+            return null;
+        }
+        return ret;
+    }
+    _updateCurrentMatch(findMatches, currentMatchesPosition) {
+        this.set(findMatches, false);
+        this._currentMatch = currentMatchesPosition % findMatches.length;
+        const nextIndex = this._findMatchesStarts.getIndexOf(this._currentMatch);
+        this.highlightCurrentFindMatchDecoration(nextIndex.index, nextIndex.remainder);
+        this._state.changeMatchInfo(this._currentMatch, this._findMatches.reduce((p, c) => p + c.length, 0), undefined);
+    }
+    _matchesCountBeforeIndex(findMatches, index) {
+        let prevMatchesCount = 0;
+        for (let i = 0; i < index; i++) {
+            prevMatchesCount += findMatches[i].length;
+        }
+        return prevMatchesCount;
+    }
+    constructFindMatchesStarts() {
+        if (this._findMatches && this._findMatches.length) {
+            const values = ( new Uint32Array(this._findMatches.length));
+            for (let i = 0; i < this._findMatches.length; i++) {
+                values[i] = this._findMatches[i].length;
+            }
+            this._findMatchesStarts = ( new PrefixSumComputer(values));
+        }
+        else {
+            this._findMatchesStarts = null;
+        }
+    }
+    async highlightCurrentFindMatchDecoration(cellIndex, matchIndex) {
+        const cell = this._findMatches[cellIndex].cell;
+        const match = this._findMatches[cellIndex].getMatch(matchIndex);
+        if (matchIndex < this._findMatches[cellIndex].contentMatches.length) {
+            return this._findMatchDecorationModel.highlightCurrentFindMatchDecorationInCell(cell, match.range);
+        }
+        else {
+            return this._findMatchDecorationModel.highlightCurrentFindMatchDecorationInWebview(cell, match.index);
+        }
+    }
+    clear() {
+        this._computePromise?.cancel();
+        this._throttledDelayer.cancel();
+        this.set([], false);
+    }
+    dispose() {
+        this._findMatchDecorationModel.dispose();
+        super.dispose();
+    }
+};
+FindModel = ( __decorate([
+    ( __param(2, IConfigurationService))
+], FindModel));
+export { CellFindMatchModel, FindModel };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .simple-fr-find-part-wrapper{background-color:var(--vscode-editorWidget-background)!important;border-bottom-left-radius:4px;border-bottom-right-radius:4px;box-shadow:0 0 8px 2px var(--vscode-widget-shadow);color:var(--vscode-editorWidget-foreground);max-width:calc(100% - 64px);overflow:hidden;padding:0 var(--notebook-find-horizontal-padding);position:absolute;right:18px;top:-45px;transition:top .2s linear;visibility:hidden;width:var(--notebook-find-width);z-index:10}.monaco-workbench.reduce-motion .simple-fr-find-part-wrapper{transition:top 0ms linear}.monaco-workbench .notebookOverlay .simple-fr-find-part-wrapper.visible{z-index:100}.monaco-workbench .simple-fr-find-part,.monaco-workbench .simple-fr-replace-part{align-items:center;display:flex;margin:0 0 0 17px;padding:4px;pointer-events:all;position:relative;top:0;z-index:10}.monaco-workbench .simple-fr-find-part-wrapper .find-replace-progress{height:2px;position:absolute;width:100%}.monaco-workbench .simple-fr-find-part-wrapper .find-replace-progress .monaco-progress-container{top:0!important;z-index:100!important}.monaco-workbench .simple-fr-find-part-wrapper .monaco-findInput{width:224px}.monaco-workbench .simple-fr-find-part-wrapper .button{align-items:center;background-position:50%;background-repeat:no-repeat;cursor:pointer;display:flex;flex:initial;height:20px;justify-content:center;margin-left:3px;width:20px}.monaco-workbench .simple-fr-find-part-wrapper.visible .simple-fr-find-part{visibility:visible}.monaco-workbench .simple-fr-find-part-wrapper .toggle{align-items:center;box-sizing:border-box;display:flex;height:100%;justify-content:center;margin-left:0;pointer-events:all;position:absolute;top:0;width:18px}.monaco-workbench .simple-fr-find-part-wrapper.visible{visibility:visible}.monaco-workbench .simple-fr-find-part-wrapper.visible-transition{top:0}.monaco-workbench .simple-fr-find-part .monaco-findInput{flex:1}.monaco-workbench .simple-fr-find-part .button{background-position:50%;background-repeat:no-repeat;cursor:pointer;display:flex;flex:initial;height:20px;margin-left:3px;min-width:20px;width:20px}.monaco-workbench .simple-fr-find-part-wrapper .button.disabled{cursor:default;opacity:.3}.monaco-workbench .simple-fr-find-part-wrapper .monaco-custom-toggle.disabled{background-color:inherit!important;cursor:default;opacity:.3;pointer-events:none;user-select:none;-webkit-user-select:none}.monaco-workbench .simple-fr-find-part-wrapper .find-filter-button{box-sizing:border-box;color:inherit;cursor:pointer;float:left;margin-left:2px;user-select:none;-webkit-user-select:none}.find-filter-button .monaco-action-bar .action-label{padding:0}.monaco-workbench .simple-fr-find-part .monaco-inputbox>.ibwrapper>.input,.monaco-workbench .simple-fr-replace-part .monaco-inputbox>.ibwrapper>.input{height:24px}.monaco-workbench .simple-fr-find-part-wrapper .monaco-sash{background-color:var(--vscode-editorWidget-resizeBorder,var(--vscode-editorWidget-border));left:0!important}";
+n(css,{});
+export { css, css as default };