@codingame/monaco-vscode-api 37.0.0 → 37.2.0

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

@@ -1,275 +0,0 @@
-
-import { renderAsPlaintext } from '../../../../../base/browser/markdownRenderer.js';
-import { Emitter } from '../../../../../base/common/event.js';
-import { DisposableStore } from '../../../../../base/common/lifecycle.js';
-import { marked } from 'marked';
-import { TrackedRangeStickiness } from '../../../../../editor/common/model.js';
-import { FoldingRegions } from '../../../../../editor/contrib/folding/browser/foldingRanges.js';
-import { sanitizeRanges } from '../../../../../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, TrackedRangeStickiness.GrowsOnlyWhenTypingAfter)
-        );
-        this._foldingRangeDecorationIds = ( cellRanges.map(
-            region => viewModel.setTrackedRange(null, region, TrackedRangeStickiness.GrowsOnlyWhenTypingAfter)
-        )).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: renderAsPlaintext({
-                    value: token.raw
-                }).trim()
-            };
-        }
-    }
-}
-
-export { FoldingModel, getMarkdownHeadersInCell };

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

@@ -1,69 +0,0 @@
-import { Emitter, Event } from "../../../../../base/common/event.js";
-import * as editorCommon from "../../../../../editor/common/editorCommon.js";
-import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
-import { CellFindMatch, CellFoldingState, EditorFoldingStateDelegate, ICellOutputViewModel, ICellViewModel, MarkupCellLayoutChangeEvent, MarkupCellLayoutInfo } from "../notebookBrowser.js";
-import { BaseCellViewModel } from "./baseCellViewModel.js";
-import { NotebookCellTextModel } from "../../common/model/notebookCellTextModel.js";
-import { CellKind, INotebookFindOptions } from "../../common/notebookCommon.js";
-import { ITextModelService } from "../../../../../editor/common/services/resolverService.service.js";
-import { ViewContext } from "./viewContext.js";
-import { IUndoRedoService } from "../../../../../platform/undoRedo/common/undoRedo.service.js";
-import { NotebookOptionsChangeEvent } from "../notebookOptions.js";
-import { ICodeEditorService } from "../../../../../editor/browser/services/codeEditorService.service.js";
-import { NotebookLayoutInfo } from "../notebookViewEvents.js";
-import { IInlineChatSessionService } from "../../../inlineChat/browser/inlineChatSessionService.service.js";
-export declare class MarkupCellViewModel extends BaseCellViewModel implements ICellViewModel {
-    readonly foldingDelegate: EditorFoldingStateDelegate;
-    readonly viewContext: ViewContext;
-    readonly cellKind = CellKind.Markup;
-    private _layoutInfo;
-    private _renderedHtml?;
-    get renderedHtml(): string | undefined;
-    set renderedHtml(value: string | undefined);
-    get layoutInfo(): MarkupCellLayoutInfo;
-    private _previewHeight;
-    set renderedMarkdownHeight(newHeight: number);
-    private _chatHeight;
-    set chatHeight(newHeight: number);
-    get chatHeight(): number;
-    private _editorHeight;
-    private _statusBarHeight;
-    set editorHeight(newHeight: number);
-    get editorHeight(): number;
-    protected readonly _onDidChangeLayout: Emitter<MarkupCellLayoutChangeEvent>;
-    readonly onDidChangeLayout: Event<MarkupCellLayoutChangeEvent>;
-    get foldingState(): CellFoldingState;
-    private _hoveringOutput;
-    get outputIsHovered(): boolean;
-    set outputIsHovered(v: boolean);
-    private _focusOnOutput;
-    get outputIsFocused(): boolean;
-    set outputIsFocused(v: boolean);
-    get inputInOutputIsFocused(): boolean;
-    set inputInOutputIsFocused(_: boolean);
-    private _hoveringCell;
-    get cellIsHovered(): boolean;
-    set cellIsHovered(v: boolean);
-    constructor(viewType: string, model: NotebookCellTextModel, initialNotebookLayoutInfo: NotebookLayoutInfo | null, foldingDelegate: EditorFoldingStateDelegate, viewContext: ViewContext, configurationService: IConfigurationService, textModelService: ITextModelService, undoRedoService: IUndoRedoService, codeEditorService: ICodeEditorService, inlineChatSessionService: IInlineChatSessionService);
-    private _computeTotalHeight;
-    private _computeFoldHintHeight;
-    updateOptions(e: NotebookOptionsChangeEvent): void;
-    /**
-     * we put outputs stuff here to make compiler happy
-     */
-    outputsViewModels: ICellOutputViewModel[];
-    getOutputOffset(index: number): number;
-    updateOutputHeight(index: number, height: number): void;
-    triggerFoldingStateChange(): void;
-    private _updateTotalHeight;
-    layoutChange(state: MarkupCellLayoutChangeEvent): void;
-    restoreEditorViewState(editorViewStates: editorCommon.ICodeEditorViewState | null, totalHeight?: number): void;
-    getDynamicHeight(): null;
-    getHeight(lineHeight: number): number;
-    protected onDidChangeTextModelContent(): void;
-    onDeselect(): void;
-    private readonly _hasFindResult;
-    readonly hasFindResult: Event<boolean>;
-    startFind(value: string, options: INotebookFindOptions): CellFindMatch | null;
-    dispose(): void;
-}

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

@@ -1,269 +0,0 @@
-
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from '../../../../../base/common/event.js';
-import { generateUuid } from '../../../../../base/common/uuid.js';
-import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
-import { CellLayoutState, CellLayoutContext, CellEditState, CellFoldingState } from '../notebookBrowser.js';
-import { BaseCellViewModel } from './baseCellViewModel.js';
-import { CellKind } from '../../common/notebookCommon.js';
-import { ITextModelService } from '../../../../../editor/common/services/resolverService.service.js';
-import { IUndoRedoService } from '../../../../../platform/undoRedo/common/undoRedo.service.js';
-import { ICodeEditorService } from '../../../../../editor/browser/services/codeEditorService.service.js';
-import { NotebookCellStateChangedEvent } from '../notebookViewEvents.js';
-import { IInlineChatSessionService } from '../../../inlineChat/browser/inlineChatSessionService.service.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 inputInOutputIsFocused() {
-        return false;
-    }
-    set inputInOutputIsFocused(_) {}
-    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,
-        inlineChatSessionService
-    ) {
-        super(
-            viewType,
-            model,
-            generateUuid(),
-            viewContext,
-            configurationService,
-            textModelService,
-            undoRedoService,
-            codeEditorService,
-            inlineChatSessionService
-        );
-        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);
-        const layoutConfiguration = this.viewContext.notebookOptions.getLayoutConfiguration();
-        this._layoutInfo = {
-            chatHeight: 0,
-            editorHeight: 0,
-            previewHeight: 0,
-            fontInfo: initialNotebookLayoutInfo?.fontInfo || null,
-            editorWidth: initialNotebookLayoutInfo?.width ? this.viewContext.notebookOptions.computeMarkdownCellEditorWidth(initialNotebookLayoutInfo.width) : 0,
-            commentOffset: 0,
-            commentHeight: 0,
-            bottomToolbarOffset: bottomToolbarGap,
-            totalHeight: 100,
-            layoutState: CellLayoutState.Uninitialized,
-            foldHintHeight: 0,
-            statusBarHeight: 0,
-            outlineWidth: 1,
-            bottomMargin: layoutConfiguration.markdownCellBottomMargin,
-            topMargin: layoutConfiguration.markdownCellTopMargin
-        };
-        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 + this._commentHeight;
-        } else {
-            return Math.max(
-                1,
-                this._previewHeight + bottomToolbarGap + foldHintHeight + this._commentHeight
-            );
-        }
-    }
-    _computeFoldHintHeight() {
-        return (this.getEditState() === CellEditState.Editing || this.foldingState !== CellFoldingState.Collapsed) ? 0 : this.viewContext.notebookOptions.getLayoutConfiguration().markdownFoldHintHeight;
-    }
-    updateOptions(e) {
-        super.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) {
-        let totalHeight;
-        let foldHintHeight;
-        if (!this.isInputCollapsed) {
-            totalHeight = state.totalHeight === undefined ? (this._layoutInfo.layoutState === CellLayoutState.Uninitialized ? 100 : this._layoutInfo.totalHeight) : state.totalHeight;
-            foldHintHeight = this._computeFoldHintHeight();
-        } else {
-            totalHeight = this.viewContext.notebookOptions.computeCollapsedMarkdownCellHeight(this.viewType);
-            state.totalHeight = totalHeight;
-            foldHintHeight = 0;
-        }
-        let commentOffset;
-        const notebookLayoutConfiguration = this.viewContext.notebookOptions.getLayoutConfiguration();
-        if (this.getEditState() === CellEditState.Editing) {
-            commentOffset =
-            notebookLayoutConfiguration.editorToolbarHeight + notebookLayoutConfiguration.cellTopMargin + this._chatHeight + this._editorHeight + this._statusBarHeight;
-        } else {
-            commentOffset = this._previewHeight;
-        }
-        this._layoutInfo = {
-            fontInfo: state.font || this._layoutInfo.fontInfo,
-            editorWidth: state.outerWidth !== undefined ? this.viewContext.notebookOptions.computeMarkdownCellEditorWidth(state.outerWidth) : this._layoutInfo.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,
-            commentOffset,
-            commentHeight: state.commentHeight ? this._commentHeight : this._layoutInfo.commentHeight,
-            outlineWidth: 1,
-            bottomMargin: notebookLayoutConfiguration.markdownCellBottomMargin,
-            topMargin: notebookLayoutConfiguration.markdownCellTopMargin
-        };
-        this._onDidChangeLayout.fire(state);
-    }
-    restoreEditorViewState(editorViewStates, totalHeight) {
-        super.restoreEditorViewState(editorViewStates);
-        if (totalHeight !== undefined && this.layoutInfo.layoutState === CellLayoutState.Uninitialized) {
-            this._layoutInfo = {
-                ...this.layoutInfo,
-                totalHeight: totalHeight,
-                chatHeight: this._chatHeight,
-                editorHeight: this._editorHeight,
-                statusBarHeight: this._statusBarHeight,
-                layoutState: CellLayoutState.FromCache
-            };
-            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)), ( __param(9, IInlineChatSessionService))], MarkupCellViewModel));
-
-export { MarkupCellViewModel };