@codingame/monaco-vscode-api 10.1.4 → 11.0.0

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

@@ -1,257 +0,0 @@
-import { renderMarkdownAsPlaintext } from '../../../../../base/browser/markdownRenderer.js';
-import { Emitter } from '../../../../../base/common/event.js';
-import { DisposableStore } from '../../../../../base/common/lifecycle.js';
-import { marked } from 'marked';
-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, 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.raw }).trim()
-            };
-        }
-    }
-}
-export { FoldingModel, getMarkdownHeadersInCell };

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

@@ -1,252 +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 } from '../notebookBrowser.js';
-import { BaseCellViewModel } from './baseCellViewModel.js';
-import { CellKind } from '../../common/notebookCommon.js';
-import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
-import { IUndoRedoService } from '../../../../../platform/undoRedo/common/undoRedo.service.js';
-import { ICodeEditorService } from '../../../../../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 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) {
-        super(viewType, model, 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,
-            commentOffset: 0,
-            commentHeight: 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
-                + this._commentHeight;
-        }
-        else {
-            return Math.max(1, this._previewHeight + bottomToolbarGap + foldHintHeight + this._commentHeight);
-        }
-    }
-    _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) {
-        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;
-        if (this.getEditState() === CellEditState.Editing) {
-            const notebookLayoutConfiguration = this.viewContext.notebookOptions.getLayoutConfiguration();
-            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,
-        };
-        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))
-], MarkupCellViewModel));
-export { MarkupCellViewModel };

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

@@ -1,3 +0,0 @@
-import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
-const INotebookCellOutlineDataSourceFactory = ( createDecorator('INotebookCellOutlineDataSourceFactory'));
-export { INotebookCellOutlineDataSourceFactory };