@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/foldingModel.js

@@ -0,0 +1,257 @@
+import { renderMarkdownAsPlaintext } from 'monaco-editor/esm/vs/base/browser/markdownRenderer.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { marked } from 'monaco-editor/esm/vs/base/common/marked/marked.js';
+import { FoldingRegions } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/foldingRanges.js';
+import { sanitizeRanges } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/syntaxRangeProvider.js';
+import { CellKind } from '../../common/notebookCommon.js';
+import { cellRangesToIndexes } from '../../common/notebookRange.js';
+const foldingRangeLimit = {
+    limit: 5000,
+    update: () => { }
+};
+class FoldingModel {
+    get regions() {
+        return this._regions;
+    }
+    constructor() {
+        this._viewModel = null;
+        this._viewModelStore = ( new DisposableStore());
+        this._onDidFoldingRegionChanges = ( new Emitter());
+        this.onDidFoldingRegionChanged = this._onDidFoldingRegionChanges.event;
+        this._foldingRangeDecorationIds = [];
+        this._regions = ( new FoldingRegions(( new Uint32Array(0)), ( new Uint32Array(0))));
+    }
+    dispose() {
+        this._onDidFoldingRegionChanges.dispose();
+        this._viewModelStore.dispose();
+    }
+    detachViewModel() {
+        this._viewModelStore.clear();
+        this._viewModel = null;
+    }
+    attachViewModel(model) {
+        this._viewModel = model;
+        this._viewModelStore.add(this._viewModel.onDidChangeViewCells(() => {
+            this.recompute();
+        }));
+        this._viewModelStore.add(this._viewModel.onDidChangeSelection(() => {
+            if (!this._viewModel) {
+                return;
+            }
+            const indexes = cellRangesToIndexes(this._viewModel.getSelections());
+            let changed = false;
+            indexes.forEach(index => {
+                let regionIndex = this.regions.findRange(index + 1);
+                while (regionIndex !== -1) {
+                    if (this._regions.isCollapsed(regionIndex) && index > this._regions.getStartLineNumber(regionIndex) - 1) {
+                        this._regions.setCollapsed(regionIndex, false);
+                        changed = true;
+                    }
+                    regionIndex = this._regions.getParentIndex(regionIndex);
+                }
+            });
+            if (changed) {
+                this._onDidFoldingRegionChanges.fire();
+            }
+        }));
+        this.recompute();
+    }
+    getRegionAtLine(lineNumber) {
+        if (this._regions) {
+            const index = this._regions.findRange(lineNumber);
+            if (index >= 0) {
+                return this._regions.toRegion(index);
+            }
+        }
+        return null;
+    }
+    getRegionsInside(region, filter) {
+        const result = [];
+        const index = region ? region.regionIndex + 1 : 0;
+        const endLineNumber = region ? region.endLineNumber : Number.MAX_VALUE;
+        if (filter && filter.length === 2) {
+            const levelStack = [];
+            for (let i = index, len = this._regions.length; i < len; i++) {
+                const current = this._regions.toRegion(i);
+                if (this._regions.getStartLineNumber(i) < endLineNumber) {
+                    while (levelStack.length > 0 && !current.containedBy(levelStack[levelStack.length - 1])) {
+                        levelStack.pop();
+                    }
+                    levelStack.push(current);
+                    if (filter(current, levelStack.length)) {
+                        result.push(current);
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            for (let i = index, len = this._regions.length; i < len; i++) {
+                const current = this._regions.toRegion(i);
+                if (this._regions.getStartLineNumber(i) < endLineNumber) {
+                    if (!filter || filter(current)) {
+                        result.push(current);
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    getAllRegionsAtLine(lineNumber, filter) {
+        const result = [];
+        if (this._regions) {
+            let index = this._regions.findRange(lineNumber);
+            let level = 1;
+            while (index >= 0) {
+                const current = this._regions.toRegion(index);
+                if (!filter || filter(current, level)) {
+                    result.push(current);
+                }
+                level++;
+                index = current.parentIndex;
+            }
+        }
+        return result;
+    }
+    setCollapsed(index, newState) {
+        this._regions.setCollapsed(index, newState);
+    }
+    recompute() {
+        if (!this._viewModel) {
+            return;
+        }
+        const viewModel = this._viewModel;
+        const cells = viewModel.viewCells;
+        const stack = [];
+        for (let i = 0; i < cells.length; i++) {
+            const cell = cells[i];
+            if (cell.cellKind !== CellKind.Markup || cell.language !== 'markdown') {
+                continue;
+            }
+            const minDepth = Math.min(7, ...Array.from(getMarkdownHeadersInCell(cell.getText()), header => header.depth));
+            if (minDepth < 7) {
+                stack.push({ index: i, level: minDepth, endIndex: 0 });
+            }
+        }
+        const rawFoldingRanges = ( stack.map((entry, startIndex) => {
+            let end = undefined;
+            for (let i = startIndex + 1; i < stack.length; ++i) {
+                if (stack[i].level <= entry.level) {
+                    end = stack[i].index - 1;
+                    break;
+                }
+            }
+            const endIndex = end !== undefined ? end : cells.length - 1;
+            return {
+                start: entry.index + 1,
+                end: endIndex + 1,
+                rank: 1
+            };
+        })).filter(range => range.start !== range.end);
+        const newRegions = sanitizeRanges(rawFoldingRanges, foldingRangeLimit);
+        let i = 0;
+        const nextCollapsed = () => {
+            while (i < this._regions.length) {
+                const isCollapsed = this._regions.isCollapsed(i);
+                i++;
+                if (isCollapsed) {
+                    return i - 1;
+                }
+            }
+            return -1;
+        };
+        let k = 0;
+        let collapsedIndex = nextCollapsed();
+        while (collapsedIndex !== -1 && k < newRegions.length) {
+            const decRange = viewModel.getTrackedRange(this._foldingRangeDecorationIds[collapsedIndex]);
+            if (decRange) {
+                const collasedStartIndex = decRange.start;
+                while (k < newRegions.length) {
+                    const startIndex = newRegions.getStartLineNumber(k) - 1;
+                    if (collasedStartIndex >= startIndex) {
+                        newRegions.setCollapsed(k, collasedStartIndex === startIndex);
+                        k++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            collapsedIndex = nextCollapsed();
+        }
+        while (k < newRegions.length) {
+            newRegions.setCollapsed(k, false);
+            k++;
+        }
+        const cellRanges = [];
+        for (let i = 0; i < newRegions.length; i++) {
+            const region = newRegions.toRegion(i);
+            cellRanges.push({ start: region.startLineNumber - 1, end: region.endLineNumber - 1 });
+        }
+        this._foldingRangeDecorationIds.forEach(id => viewModel.setTrackedRange(id, null, 3 ));
+        this._foldingRangeDecorationIds = ( cellRanges.map(
+            region => viewModel.setTrackedRange(null, region, 3 )
+        )).filter(str => str !== null);
+        this._regions = newRegions;
+        this._onDidFoldingRegionChanges.fire();
+    }
+    getMemento() {
+        const collapsedRanges = [];
+        let i = 0;
+        while (i < this._regions.length) {
+            const isCollapsed = this._regions.isCollapsed(i);
+            if (isCollapsed) {
+                const region = this._regions.toRegion(i);
+                collapsedRanges.push({ start: region.startLineNumber - 1, end: region.endLineNumber - 1 });
+            }
+            i++;
+        }
+        return collapsedRanges;
+    }
+    applyMemento(state) {
+        if (!this._viewModel) {
+            return false;
+        }
+        let i = 0;
+        let k = 0;
+        while (k < state.length && i < this._regions.length) {
+            const decRange = this._viewModel.getTrackedRange(this._foldingRangeDecorationIds[i]);
+            if (decRange) {
+                const collasedStartIndex = state[k].start;
+                while (i < this._regions.length) {
+                    const startIndex = this._regions.getStartLineNumber(i) - 1;
+                    if (collasedStartIndex >= startIndex) {
+                        this._regions.setCollapsed(i, collasedStartIndex === startIndex);
+                        i++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            k++;
+        }
+        while (i < this._regions.length) {
+            this._regions.setCollapsed(i, false);
+            i++;
+        }
+        return true;
+    }
+}
+function* getMarkdownHeadersInCell(cellContent) {
+    for (const token of marked.lexer(cellContent, { gfm: true })) {
+        if (token.type === 'heading') {
+            yield {
+                depth: token.depth,
+                text: renderMarkdownAsPlaintext({ value: token.text }).trim()
+            };
+        }
+    }
+}
+export { FoldingModel, getMarkdownHeadersInCell };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/markupCellViewModel.js

@@ -0,0 +1,239 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import * as UUID from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { CellLayoutState, CellLayoutContext, CellEditState } from '../notebookBrowser.js';
+import { BaseCellViewModel } from './baseCellViewModel.js';
+import { CellKind } from '../../common/notebookCommon.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { NotebookCellStateChangedEvent } from '../notebookViewEvents.js';
+let MarkupCellViewModel = class MarkupCellViewModel extends BaseCellViewModel {
+    get renderedHtml() { return this._renderedHtml; }
+    set renderedHtml(value) {
+        if (this._renderedHtml !== value) {
+            this._renderedHtml = value;
+            this._onDidChangeState.fire({ contentChanged: true });
+        }
+    }
+    get layoutInfo() {
+        return this._layoutInfo;
+    }
+    set renderedMarkdownHeight(newHeight) {
+        this._previewHeight = newHeight;
+        this._updateTotalHeight(this._computeTotalHeight());
+    }
+    set chatHeight(newHeight) {
+        this._chatHeight = newHeight;
+        this._updateTotalHeight(this._computeTotalHeight());
+    }
+    get chatHeight() {
+        return this._chatHeight;
+    }
+    set editorHeight(newHeight) {
+        this._editorHeight = newHeight;
+        this._statusBarHeight = this.viewContext.notebookOptions.computeStatusBarHeight();
+        this._updateTotalHeight(this._computeTotalHeight());
+    }
+    get editorHeight() {
+        throw new Error('MarkdownCellViewModel.editorHeight is write only');
+    }
+    get foldingState() {
+        return this.foldingDelegate.getFoldingState(this.foldingDelegate.getCellIndex(this));
+    }
+    get outputIsHovered() {
+        return this._hoveringOutput;
+    }
+    set outputIsHovered(v) {
+        this._hoveringOutput = v;
+    }
+    get outputIsFocused() {
+        return this._focusOnOutput;
+    }
+    set outputIsFocused(v) {
+        this._focusOnOutput = v;
+    }
+    get cellIsHovered() {
+        return this._hoveringCell;
+    }
+    set cellIsHovered(v) {
+        this._hoveringCell = v;
+        this._onDidChangeState.fire({ cellIsHoveredChanged: true });
+    }
+    constructor(viewType, model, initialNotebookLayoutInfo, foldingDelegate, viewContext, configurationService, textModelService, undoRedoService, codeEditorService) {
+        super(viewType, model, UUID.generateUuid(), viewContext, configurationService, textModelService, undoRedoService, codeEditorService);
+        this.foldingDelegate = foldingDelegate;
+        this.viewContext = viewContext;
+        this.cellKind = CellKind.Markup;
+        this._previewHeight = 0;
+        this._chatHeight = 0;
+        this._editorHeight = 0;
+        this._statusBarHeight = 0;
+        this._onDidChangeLayout = this._register(( new Emitter()));
+        this.onDidChangeLayout = this._onDidChangeLayout.event;
+        this._hoveringOutput = false;
+        this._focusOnOutput = false;
+        this._hoveringCell = false;
+        this.outputsViewModels = [];
+        this._hasFindResult = this._register(( new Emitter()));
+        this.hasFindResult = this._hasFindResult.event;
+        const { bottomToolbarGap } = this.viewContext.notebookOptions.computeBottomToolbarDimensions(this.viewType);
+        this._layoutInfo = {
+            chatHeight: 0,
+            editorHeight: 0,
+            previewHeight: 0,
+            fontInfo: initialNotebookLayoutInfo?.fontInfo || null,
+            editorWidth: initialNotebookLayoutInfo?.width
+                ? this.viewContext.notebookOptions.computeMarkdownCellEditorWidth(initialNotebookLayoutInfo.width)
+                : 0,
+            bottomToolbarOffset: bottomToolbarGap,
+            totalHeight: 100,
+            layoutState: CellLayoutState.Uninitialized,
+            foldHintHeight: 0,
+            statusBarHeight: 0
+        };
+        this._register(this.onDidChangeState(e => {
+            this.viewContext.eventDispatcher.emit([( new NotebookCellStateChangedEvent(e, this.model))]);
+            if (e.foldingStateChanged) {
+                this._updateTotalHeight(this._computeTotalHeight(), CellLayoutContext.Fold);
+            }
+        }));
+    }
+    _computeTotalHeight() {
+        const layoutConfiguration = this.viewContext.notebookOptions.getLayoutConfiguration();
+        const { bottomToolbarGap } = this.viewContext.notebookOptions.computeBottomToolbarDimensions(this.viewType);
+        const foldHintHeight = this._computeFoldHintHeight();
+        if (this.getEditState() === CellEditState.Editing) {
+            return this._editorHeight
+                + layoutConfiguration.markdownCellTopMargin
+                + layoutConfiguration.markdownCellBottomMargin
+                + bottomToolbarGap
+                + this._statusBarHeight;
+        }
+        else {
+            return Math.max(1, this._previewHeight + bottomToolbarGap + foldHintHeight);
+        }
+    }
+    _computeFoldHintHeight() {
+        return ((this.getEditState() === CellEditState.Editing || this.foldingState !== 2) ) ?
+            0 : this.viewContext.notebookOptions.getLayoutConfiguration().markdownFoldHintHeight;
+    }
+    updateOptions(e) {
+        if (e.cellStatusBarVisibility || e.insertToolbarPosition || e.cellToolbarLocation) {
+            this._updateTotalHeight(this._computeTotalHeight());
+        }
+    }
+    getOutputOffset(index) {
+        return -1;
+    }
+    updateOutputHeight(index, height) {
+    }
+    triggerFoldingStateChange() {
+        this._onDidChangeState.fire({ foldingStateChanged: true });
+    }
+    _updateTotalHeight(newHeight, context) {
+        if (newHeight !== this.layoutInfo.totalHeight) {
+            this.layoutChange({ totalHeight: newHeight, context });
+        }
+    }
+    layoutChange(state) {
+        const foldHintHeight = this._computeFoldHintHeight();
+        if (!this.isInputCollapsed) {
+            const editorWidth = state.outerWidth !== undefined
+                ? this.viewContext.notebookOptions.computeMarkdownCellEditorWidth(state.outerWidth)
+                : this._layoutInfo.editorWidth;
+            const totalHeight = state.totalHeight === undefined
+                ? (this._layoutInfo.layoutState === CellLayoutState.Uninitialized ? 100 : this._layoutInfo.totalHeight)
+                : state.totalHeight;
+            const previewHeight = this._previewHeight;
+            this._layoutInfo = {
+                fontInfo: state.font || this._layoutInfo.fontInfo,
+                editorWidth,
+                previewHeight,
+                chatHeight: this._chatHeight,
+                editorHeight: this._editorHeight,
+                statusBarHeight: this._statusBarHeight,
+                bottomToolbarOffset: this.viewContext.notebookOptions.computeBottomToolbarOffset(totalHeight, this.viewType),
+                totalHeight,
+                layoutState: CellLayoutState.Measured,
+                foldHintHeight
+            };
+        }
+        else {
+            const editorWidth = state.outerWidth !== undefined
+                ? this.viewContext.notebookOptions.computeMarkdownCellEditorWidth(state.outerWidth)
+                : this._layoutInfo.editorWidth;
+            const totalHeight = this.viewContext.notebookOptions.computeCollapsedMarkdownCellHeight(this.viewType);
+            state.totalHeight = totalHeight;
+            this._layoutInfo = {
+                fontInfo: state.font || this._layoutInfo.fontInfo,
+                editorWidth,
+                chatHeight: this._chatHeight,
+                editorHeight: this._editorHeight,
+                statusBarHeight: this._statusBarHeight,
+                previewHeight: this._previewHeight,
+                bottomToolbarOffset: this.viewContext.notebookOptions.computeBottomToolbarOffset(totalHeight, this.viewType),
+                totalHeight,
+                layoutState: CellLayoutState.Measured,
+                foldHintHeight: 0
+            };
+        }
+        this._onDidChangeLayout.fire(state);
+    }
+    restoreEditorViewState(editorViewStates, totalHeight) {
+        super.restoreEditorViewState(editorViewStates);
+        if (totalHeight !== undefined && this.layoutInfo.layoutState === CellLayoutState.Uninitialized) {
+            this._layoutInfo = {
+                fontInfo: this._layoutInfo.fontInfo,
+                editorWidth: this._layoutInfo.editorWidth,
+                previewHeight: this._layoutInfo.previewHeight,
+                bottomToolbarOffset: this._layoutInfo.bottomToolbarOffset,
+                totalHeight: totalHeight,
+                chatHeight: this._chatHeight,
+                editorHeight: this._editorHeight,
+                statusBarHeight: this._statusBarHeight,
+                layoutState: CellLayoutState.FromCache,
+                foldHintHeight: this._layoutInfo.foldHintHeight
+            };
+            this.layoutChange({});
+        }
+    }
+    getDynamicHeight() {
+        return null;
+    }
+    getHeight(lineHeight) {
+        if (this._layoutInfo.layoutState === CellLayoutState.Uninitialized) {
+            return 100;
+        }
+        else {
+            return this._layoutInfo.totalHeight;
+        }
+    }
+    onDidChangeTextModelContent() {
+        this._onDidChangeState.fire({ contentChanged: true });
+    }
+    onDeselect() {
+    }
+    startFind(value, options) {
+        const matches = super.cellStartFind(value, options);
+        if (matches === null) {
+            return null;
+        }
+        return {
+            cell: this,
+            contentMatches: matches
+        };
+    }
+    dispose() {
+        super.dispose();
+        this.foldingDelegate = null;
+    }
+};
+MarkupCellViewModel = ( __decorate([
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, IUndoRedoService)),
+    ( __param(8, ICodeEditorService))
+], MarkupCellViewModel));
+export { MarkupCellViewModel };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory.js

@@ -0,0 +1,103 @@
+import { renderMarkdownAsPlaintext } from 'monaco-editor/esm/vs/base/browser/markdownRenderer.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { getMarkdownHeadersInCell } from './foldingModel.js';
+import { OutlineEntry } from './OutlineEntry.js';
+import { CellKind } from '../../common/notebookCommon.js';
+class NotebookOutlineEntryFactory {
+    constructor(executionStateService) {
+        this.executionStateService = executionStateService;
+        this.cellOutlineEntryCache = {};
+    }
+    getOutlineEntries(cell, index) {
+        const entries = [];
+        const isMarkdown = cell.cellKind === CellKind.Markup;
+        let content = getCellFirstNonEmptyLine(cell);
+        let hasHeader = false;
+        if (isMarkdown) {
+            const fullContent = cell.getText().substring(0, 10000);
+            for (const { depth, text } of getMarkdownHeadersInCell(fullContent)) {
+                hasHeader = true;
+                entries.push(( new OutlineEntry(index++, depth, cell, text, false, false)));
+            }
+            if (!hasHeader) {
+                const match = fullContent.match(/<h([1-6]).*>(.*)<\/h\1>/i);
+                if (match) {
+                    hasHeader = true;
+                    const level = parseInt(match[1]);
+                    const text = match[2].trim();
+                    entries.push(( new OutlineEntry(index++, level, cell, text, false, false)));
+                }
+            }
+            if (!hasHeader) {
+                content = renderMarkdownAsPlaintext({ value: content });
+            }
+        }
+        if (!hasHeader) {
+            if (!isMarkdown && cell.model.textModel) {
+                const cachedEntries = this.cellOutlineEntryCache[cell.model.textModel.id];
+                if (cachedEntries) {
+                    cachedEntries.forEach((cached) => {
+                        entries.push(( new OutlineEntry(
+                            index++,
+                            cached.level,
+                            cell,
+                            cached.name,
+                            false,
+                            false,
+                            cached.range,
+                            cached.kind
+                        )));
+                    });
+                }
+            }
+            const exeState = !isMarkdown && this.executionStateService.getCellExecution(cell.uri);
+            if (entries.length === 0) {
+                let preview = content.trim();
+                if (preview.length === 0) {
+                    preview = ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory',
+                        'empty',
+                        "empty cell"
+                    ));
+                }
+                entries.push(( new OutlineEntry(
+                    index++,
+                    7,
+                    cell,
+                    preview,
+                    !!exeState,
+                    exeState ? exeState.isPaused : false
+                )));
+            }
+        }
+        return entries;
+    }
+    async cacheSymbols(cell, outlineModelService, cancelToken) {
+        const textModel = await cell.resolveTextModel();
+        const outlineModel = await outlineModelService.getOrCreate(textModel, cancelToken);
+        const entries = createOutlineEntries(outlineModel.getTopLevelSymbols(), 7);
+        this.cellOutlineEntryCache[textModel.id] = entries;
+    }
+}
+function createOutlineEntries(symbols, level) {
+    const entries = [];
+    symbols.forEach(symbol => {
+        entries.push({ name: symbol.name, range: symbol.range, level, kind: symbol.kind });
+        if (symbol.children) {
+            entries.push(...createOutlineEntries(symbol.children, level + 1));
+        }
+    });
+    return entries;
+}
+function getCellFirstNonEmptyLine(cell) {
+    const textBuffer = cell.textBuffer;
+    for (let i = 0; i < textBuffer.getLineCount(); i++) {
+        const firstNonWhitespace = textBuffer.getLineFirstNonWhitespaceColumn(i + 1);
+        const lineLength = textBuffer.getLineLength(i + 1);
+        if (firstNonWhitespace < lineLength) {
+            return textBuffer.getLineContent(i + 1);
+        }
+    }
+    return cell.getText().substring(0, 100);
+}
+export { NotebookOutlineEntryFactory };