@codingame/monaco-vscode-api 37.0.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellDnd.js

@@ -1,429 +0,0 @@
-
-import { $ as $$1, append, addDisposableListener, EventType, isAncestor } from '../../../../../../base/browser/dom.js';
-import { Delayer } from '../../../../../../base/common/async.js';
-import { Disposable, MutableDisposable } from '../../../../../../base/common/lifecycle.js';
-import { isMacintosh } from '../../../../../../base/common/platform.js';
-import { expandCellRangesWithHiddenCells } from '../../notebookBrowser.js';
-import { CellContentPart } from '../cellPart.js';
-import { cloneNotebookCellTextModel } from '../../../common/model/notebookCellTextModel.js';
-import { CellEditType, SelectionStateType } from '../../../common/notebookCommon.js';
-import { cellRangesToIndexes } from '../../../common/notebookRange.js';
-
-const $ = $$1;
-const DRAGGING_CLASS = "cell-dragging";
-const GLOBAL_DRAG_CLASS = "global-drag-active";
-class CellDragAndDropPart extends CellContentPart {
-    constructor(container) {
-        super();
-        this.container = container;
-    }
-    didRenderCell(element) {
-        this.update(element);
-    }
-    updateState(element, e) {
-        if (e.dragStateChanged) {
-            this.update(element);
-        }
-    }
-    update(element) {
-        this.container.classList.toggle(DRAGGING_CLASS, element.dragging);
-    }
-}
-class CellDragAndDropController extends Disposable {
-    constructor(notebookEditor, notebookListContainer) {
-        super();
-        this.notebookEditor = notebookEditor;
-        this.notebookListContainer = notebookListContainer;
-        this.draggedCells = [];
-        this.isScrolling = false;
-        this.listOnWillScrollListener = this._register(( new MutableDisposable()));
-        this.listInsertionIndicator = append(notebookListContainer, $(".cell-list-insertion-indicator"));
-        this._register(addDisposableListener(
-            notebookListContainer.ownerDocument.body,
-            EventType.DRAG_START,
-            this.onGlobalDragStart.bind(this),
-            true
-        ));
-        this._register(addDisposableListener(
-            notebookListContainer.ownerDocument.body,
-            EventType.DRAG_END,
-            this.onGlobalDragEnd.bind(this),
-            true
-        ));
-        const addCellDragListener = (eventType, handler, useCapture = false) => {
-            this._register(addDisposableListener(notebookEditor.getDomNode(), eventType, e => {
-                const cellDragEvent = this.toCellDragEvent(e);
-                if (cellDragEvent) {
-                    handler(cellDragEvent);
-                }
-            }, useCapture));
-        };
-        addCellDragListener(EventType.DRAG_OVER, event => {
-            if (!this.currentDraggedCell) {
-                return;
-            }
-            event.browserEvent.preventDefault();
-            this.onCellDragover(event);
-        }, true);
-        addCellDragListener(EventType.DROP, event => {
-            if (!this.currentDraggedCell) {
-                return;
-            }
-            event.browserEvent.preventDefault();
-            this.onCellDrop(event);
-        });
-        addCellDragListener(EventType.DRAG_LEAVE, event => {
-            event.browserEvent.preventDefault();
-            this.onCellDragLeave(event);
-        });
-        this.scrollingDelayer = this._register(( new Delayer(200)));
-    }
-    setList(value) {
-        this.list = value;
-        this.listOnWillScrollListener.value = this.list.onWillScroll(e => {
-            if (!e.scrollTopChanged) {
-                return;
-            }
-            this.setInsertIndicatorVisibility(false);
-            this.isScrolling = true;
-            this.scrollingDelayer.trigger(() => {
-                this.isScrolling = false;
-            });
-        });
-    }
-    setInsertIndicatorVisibility(visible) {
-        this.listInsertionIndicator.style.opacity = visible ? "1" : "0";
-    }
-    toCellDragEvent(event) {
-        const targetTop = this.notebookListContainer.getBoundingClientRect().top;
-        const dragOffset = this.list.scrollTop + event.clientY - targetTop;
-        const draggedOverCell = this.list.elementAt(dragOffset);
-        if (!draggedOverCell) {
-            return undefined;
-        }
-        const cellTop = this.list.getCellViewScrollTop(draggedOverCell);
-        const cellHeight = this.list.elementHeight(draggedOverCell);
-        const dragPosInElement = dragOffset - cellTop;
-        const dragPosRatio = dragPosInElement / cellHeight;
-        return {
-            browserEvent: event,
-            draggedOverCell,
-            cellTop,
-            cellHeight,
-            dragPosRatio
-        };
-    }
-    clearGlobalDragState() {
-        this.notebookEditor.getDomNode().classList.remove(GLOBAL_DRAG_CLASS);
-    }
-    onGlobalDragStart() {
-        this.notebookEditor.getDomNode().classList.add(GLOBAL_DRAG_CLASS);
-    }
-    onGlobalDragEnd() {
-        this.notebookEditor.getDomNode().classList.remove(GLOBAL_DRAG_CLASS);
-    }
-    onCellDragover(event) {
-        if (!event.browserEvent.dataTransfer) {
-            return;
-        }
-        if (!this.currentDraggedCell) {
-            event.browserEvent.dataTransfer.dropEffect = "none";
-            return;
-        }
-        if (this.isScrolling || this.currentDraggedCell === event.draggedOverCell) {
-            this.setInsertIndicatorVisibility(false);
-            return;
-        }
-        const dropDirection = this.getDropInsertDirection(event.dragPosRatio);
-        const insertionIndicatorAbsolutePos = dropDirection === "above" ? event.cellTop : event.cellTop + event.cellHeight;
-        this.updateInsertIndicator(dropDirection, insertionIndicatorAbsolutePos);
-    }
-    updateInsertIndicator(dropDirection, insertionIndicatorAbsolutePos) {
-        const {
-            bottomToolbarGap
-        } = this.notebookEditor.notebookOptions.computeBottomToolbarDimensions(this.notebookEditor.textModel?.viewType);
-        const insertionIndicatorTop = insertionIndicatorAbsolutePos - this.list.scrollTop + bottomToolbarGap / 2;
-        if (insertionIndicatorTop >= 0) {
-            this.listInsertionIndicator.style.top = `${insertionIndicatorTop}px`;
-            this.setInsertIndicatorVisibility(true);
-        } else {
-            this.setInsertIndicatorVisibility(false);
-        }
-    }
-    getDropInsertDirection(dragPosRatio) {
-        return dragPosRatio < 0.5 ? "above" : "below";
-    }
-    onCellDrop(event) {
-        const draggedCell = this.currentDraggedCell;
-        if (this.isScrolling || this.currentDraggedCell === event.draggedOverCell) {
-            return;
-        }
-        this.dragCleanup();
-        const dropDirection = this.getDropInsertDirection(event.dragPosRatio);
-        this._dropImpl(draggedCell, dropDirection, event.browserEvent, event.draggedOverCell);
-    }
-    getCellRangeAroundDragTarget(draggedCellIndex) {
-        const selections = this.notebookEditor.getSelections();
-        const modelRanges = expandCellRangesWithHiddenCells(this.notebookEditor, selections);
-        const nearestRange = modelRanges.find(range => range.start <= draggedCellIndex && draggedCellIndex < range.end);
-        if (nearestRange) {
-            return nearestRange;
-        } else {
-            return {
-                start: draggedCellIndex,
-                end: draggedCellIndex + 1
-            };
-        }
-    }
-    _dropImpl(draggedCell, dropDirection, ctx, draggedOverCell) {
-        const cellTop = this.list.getCellViewScrollTop(draggedOverCell);
-        const cellHeight = this.list.elementHeight(draggedOverCell);
-        const insertionIndicatorAbsolutePos = dropDirection === "above" ? cellTop : cellTop + cellHeight;
-        const {
-            bottomToolbarGap
-        } = this.notebookEditor.notebookOptions.computeBottomToolbarDimensions(this.notebookEditor.textModel?.viewType);
-        const insertionIndicatorTop = insertionIndicatorAbsolutePos - this.list.scrollTop + bottomToolbarGap / 2;
-        const editorHeight = this.notebookEditor.getDomNode().getBoundingClientRect().height;
-        if (insertionIndicatorTop < 0 || insertionIndicatorTop > editorHeight) {
-            return;
-        }
-        const isCopy = (ctx.ctrlKey && !isMacintosh) || (ctx.altKey && isMacintosh);
-        if (!this.notebookEditor.hasModel()) {
-            return;
-        }
-        const textModel = this.notebookEditor.textModel;
-        if (isCopy) {
-            const draggedCellIndex = this.notebookEditor.getCellIndex(draggedCell);
-            const range = this.getCellRangeAroundDragTarget(draggedCellIndex);
-            let originalToIdx = this.notebookEditor.getCellIndex(draggedOverCell);
-            if (dropDirection === "below") {
-                const relativeToIndex = this.notebookEditor.getCellIndex(draggedOverCell);
-                const newIdx = this.notebookEditor.getNextVisibleCellIndex(relativeToIndex);
-                originalToIdx = newIdx;
-            }
-            let finalSelection;
-            let finalFocus;
-            if (originalToIdx <= range.start) {
-                finalSelection = {
-                    start: originalToIdx,
-                    end: originalToIdx + range.end - range.start
-                };
-                finalFocus = {
-                    start: originalToIdx + draggedCellIndex - range.start,
-                    end: originalToIdx + draggedCellIndex - range.start + 1
-                };
-            } else {
-                const delta = (originalToIdx - range.start);
-                finalSelection = {
-                    start: range.start + delta,
-                    end: range.end + delta
-                };
-                finalFocus = {
-                    start: draggedCellIndex + delta,
-                    end: draggedCellIndex + delta + 1
-                };
-            }
-            textModel.applyEdits([{
-                editType: CellEditType.Replace,
-                index: originalToIdx,
-                count: 0,
-                cells: ( cellRangesToIndexes([range]).map(
-                    index => cloneNotebookCellTextModel(this.notebookEditor.cellAt(index).model)
-                ))
-            }], true, {
-                kind: SelectionStateType.Index,
-                focus: this.notebookEditor.getFocus(),
-                selections: this.notebookEditor.getSelections()
-            }, () => ({
-                kind: SelectionStateType.Index,
-                focus: finalFocus,
-                selections: [finalSelection]
-            }), undefined, true);
-            this.notebookEditor.revealCellRangeInView(finalSelection);
-        } else {
-            performCellDropEdits(this.notebookEditor, draggedCell, dropDirection, draggedOverCell);
-        }
-    }
-    onCellDragLeave(event) {
-        if (!event.browserEvent.relatedTarget || !isAncestor(event.browserEvent.relatedTarget, this.notebookEditor.getDomNode())) {
-            this.setInsertIndicatorVisibility(false);
-        }
-    }
-    dragCleanup() {
-        if (this.currentDraggedCell) {
-            this.draggedCells.forEach(cell => cell.dragging = false);
-            this.currentDraggedCell = undefined;
-            this.draggedCells = [];
-        }
-        this.setInsertIndicatorVisibility(false);
-    }
-    registerDragHandle(templateData, cellRoot, dragHandles, dragImageProvider) {
-        const container = templateData.container;
-        for (const dragHandle of dragHandles) {
-            dragHandle.setAttribute("draggable", "true");
-        }
-        const onDragEnd = () => {
-            if (!this.notebookEditor.notebookOptions.getDisplayOptions().dragAndDropEnabled || !!this.notebookEditor.isReadOnly) {
-                return;
-            }
-            container.classList.remove(DRAGGING_CLASS);
-            this.dragCleanup();
-        };
-        for (const dragHandle of dragHandles) {
-            templateData.templateDisposables.add(addDisposableListener(dragHandle, EventType.DRAG_END, onDragEnd));
-        }
-        const onDragStart = event => {
-            if (!event.dataTransfer) {
-                return;
-            }
-            if (!this.notebookEditor.notebookOptions.getDisplayOptions().dragAndDropEnabled || !!this.notebookEditor.isReadOnly) {
-                return;
-            }
-            this.currentDraggedCell = templateData.currentRenderedCell;
-            this.draggedCells = ( this.notebookEditor.getSelections().map(range => this.notebookEditor.getCellsInRange(range))).flat();
-            this.draggedCells.forEach(cell => cell.dragging = true);
-            const dragImage = dragImageProvider();
-            cellRoot.parentElement.appendChild(dragImage);
-            event.dataTransfer.setDragImage(dragImage, 0, 0);
-            setTimeout(() => dragImage.remove(), 0);
-        };
-        for (const dragHandle of dragHandles) {
-            templateData.templateDisposables.add(
-                addDisposableListener(dragHandle, EventType.DRAG_START, onDragStart)
-            );
-        }
-    }
-    startExplicitDrag(cell, _dragOffsetY) {
-        if (!this.notebookEditor.notebookOptions.getDisplayOptions().dragAndDropEnabled || !!this.notebookEditor.isReadOnly) {
-            return;
-        }
-        this.currentDraggedCell = cell;
-        this.setInsertIndicatorVisibility(true);
-    }
-    explicitDrag(cell, dragOffsetY) {
-        if (!this.notebookEditor.notebookOptions.getDisplayOptions().dragAndDropEnabled || !!this.notebookEditor.isReadOnly) {
-            return;
-        }
-        const target = this.list.elementAt(dragOffsetY);
-        if (target && target !== cell) {
-            const cellTop = this.list.getCellViewScrollTop(target);
-            const cellHeight = this.list.elementHeight(target);
-            const dropDirection = this.getExplicitDragDropDirection(dragOffsetY, cellTop, cellHeight);
-            const insertionIndicatorAbsolutePos = dropDirection === "above" ? cellTop : cellTop + cellHeight;
-            this.updateInsertIndicator(dropDirection, insertionIndicatorAbsolutePos);
-        }
-        if (this.currentDraggedCell !== cell) {
-            return;
-        }
-        const notebookViewRect = this.notebookEditor.getDomNode().getBoundingClientRect();
-        const eventPositionInView = dragOffsetY - this.list.scrollTop;
-        const notebookViewScrollMargins = 0.2;
-        const maxScrollDeltaPerFrame = 20;
-        const eventPositionRatio = eventPositionInView / notebookViewRect.height;
-        if (eventPositionRatio < notebookViewScrollMargins) {
-            this.list.scrollTop -= maxScrollDeltaPerFrame * (1 - eventPositionRatio / notebookViewScrollMargins);
-        } else if (eventPositionRatio > 1 - notebookViewScrollMargins) {
-            this.list.scrollTop += maxScrollDeltaPerFrame * (1 - ((1 - eventPositionRatio) / notebookViewScrollMargins));
-        }
-    }
-    endExplicitDrag(_cell) {
-        this.setInsertIndicatorVisibility(false);
-    }
-    explicitDrop(cell, ctx) {
-        this.currentDraggedCell = undefined;
-        this.setInsertIndicatorVisibility(false);
-        const target = this.list.elementAt(ctx.dragOffsetY);
-        if (!target || target === cell) {
-            return;
-        }
-        const cellTop = this.list.getCellViewScrollTop(target);
-        const cellHeight = this.list.elementHeight(target);
-        const dropDirection = this.getExplicitDragDropDirection(ctx.dragOffsetY, cellTop, cellHeight);
-        this._dropImpl(cell, dropDirection, ctx, target);
-    }
-    getExplicitDragDropDirection(clientY, cellTop, cellHeight) {
-        const dragPosInElement = clientY - cellTop;
-        const dragPosRatio = dragPosInElement / cellHeight;
-        return this.getDropInsertDirection(dragPosRatio);
-    }
-    dispose() {
-        this.notebookEditor = null;
-        super.dispose();
-    }
-}
-function performCellDropEdits(editor, draggedCell, dropDirection, draggedOverCell) {
-    const draggedCellIndex = editor.getCellIndex(draggedCell);
-    let originalToIdx = editor.getCellIndex(draggedOverCell);
-    if (typeof draggedCellIndex !== "number" || typeof originalToIdx !== "number") {
-        return;
-    }
-    if (dropDirection === "below") {
-        const newIdx = editor.getNextVisibleCellIndex(originalToIdx) ?? originalToIdx;
-        originalToIdx = newIdx;
-    }
-    let selections = editor.getSelections();
-    if (!selections.length) {
-        selections = [editor.getFocus()];
-    }
-    let originalFocusIdx = editor.getFocus().start;
-    if (!( selections.some(s => s.start <= draggedCellIndex && s.end > draggedCellIndex))) {
-        selections = [{
-            start: draggedCellIndex,
-            end: draggedCellIndex + 1
-        }];
-        originalFocusIdx = draggedCellIndex;
-    }
-    const droppedInSelection = selections.find(range => range.start <= originalToIdx && range.end > originalToIdx);
-    if (droppedInSelection) {
-        originalToIdx = droppedInSelection.start;
-    }
-    let numCells = 0;
-    let focusNewIdx = originalToIdx;
-    let newInsertionIdx = originalToIdx;
-    selections.sort((a, b) => b.start - a.start);
-    const edits = ( selections.map(range => {
-        const length = range.end - range.start;
-        let toIndexDelta = 0;
-        if (range.end <= newInsertionIdx) {
-            toIndexDelta = -length;
-        }
-        const newIdx = newInsertionIdx + toIndexDelta;
-        if (originalFocusIdx >= range.start && originalFocusIdx <= range.end) {
-            const offset = originalFocusIdx - range.start;
-            focusNewIdx = newIdx + offset;
-        }
-        const fromIndexDelta = range.start >= originalToIdx ? numCells : 0;
-        const edit = {
-            editType: CellEditType.Move,
-            index: range.start + fromIndexDelta,
-            length,
-            newIdx
-        };
-        numCells += length;
-        if (range.end < newInsertionIdx) {
-            newInsertionIdx -= length;
-        }
-        return edit;
-    }));
-    const lastEdit = edits[edits.length - 1];
-    const finalSelection = {
-        start: lastEdit.newIdx,
-        end: lastEdit.newIdx + numCells
-    };
-    const finalFocus = {
-        start: focusNewIdx,
-        end: focusNewIdx + 1
-    };
-    editor.textModel.applyEdits(edits, true, {
-        kind: SelectionStateType.Index,
-        focus: editor.getFocus(),
-        selections: editor.getSelections()
-    }, () => ({
-        kind: SelectionStateType.Index,
-        focus: finalFocus,
-        selections: [finalSelection]
-    }), undefined, true);
-    editor.revealCellRangeInView(finalSelection);
-}
-
-export { CellDragAndDropController, CellDragAndDropPart, performCellDropEdits };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellDragRenderer.d.ts

@@ -1,6 +0,0 @@
-import { ICodeEditor } from "../../../../../../editor/browser/editorBrowser.js";
-import { BaseCellRenderTemplate } from "../notebookRenderingCommon.js";
-export declare class CodeCellDragImageRenderer {
-    getDragImage(templateData: BaseCellRenderTemplate, editor: ICodeEditor, type: "code" | "markdown"): HTMLElement;
-    private getDragImageImpl;
-}

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellDragRenderer.js

@@ -1,108 +0,0 @@
-
-import { $, createElement, reset } from '../../../../../../base/browser/dom.js';
-import { createTrustedTypesPolicy } from '../../../../../../base/browser/trustedTypes.js';
-import { Color } from '../../../../../../base/common/color.js';
-import { isWindows } from '../../../../../../base/common/platform.js';
-import { EditorOption } from '../../../../../../editor/common/config/editorOptions.js';
-import { Range } from '../../../../../../editor/common/core/range.js';
-import { ColorId } from '../../../../../../editor/common/encodedTokenAttributes.js';
-import { TokenizationRegistry } from '../../../../../../editor/common/languages.js';
-import { tokenizeLineToHTML } from '../../../../../../editor/common/languages/textToHtmlTokenizer.js';
-
-class EditorTextRenderer {
-    static {
-        this._ttPolicy = createTrustedTypesPolicy("cellRendererEditorText", {
-            createHTML(input) {
-                return input;
-            }
-        });
-    }
-    getRichText(editor, modelRange) {
-        const model = editor.getModel();
-        if (!model) {
-            return null;
-        }
-        const colorMap = this.getDefaultColorMap();
-        const fontInfo = editor.getOptions().get(EditorOption.fontInfo);
-        const fontFamilyVar = "--notebook-editor-font-family";
-        const fontSizeVar = "--notebook-editor-font-size";
-        const fontWeightVar = "--notebook-editor-font-weight";
-        const style = `` + `color: ${colorMap[ColorId.DefaultForeground]};` + `background-color: ${colorMap[ColorId.DefaultBackground]};` + `font-family: var(${fontFamilyVar});` + `font-weight: var(${fontWeightVar});` + `font-size: var(${fontSizeVar});` + `line-height: ${fontInfo.lineHeight}px;` + `white-space: pre;`;
-        const element = $("div", {
-            style
-        });
-        const fontSize = fontInfo.fontSize;
-        const fontWeight = fontInfo.fontWeight;
-        element.style.setProperty(fontFamilyVar, fontInfo.fontFamily);
-        element.style.setProperty(fontSizeVar, `${fontSize}px`);
-        element.style.setProperty(fontWeightVar, fontWeight);
-        const linesHtml = this.getRichTextLinesAsHtml(model, modelRange, colorMap);
-        element.innerHTML = linesHtml;
-        return element;
-    }
-    getRichTextLinesAsHtml(model, modelRange, colorMap) {
-        const startLineNumber = modelRange.startLineNumber;
-        const startColumn = modelRange.startColumn;
-        const endLineNumber = modelRange.endLineNumber;
-        const endColumn = modelRange.endColumn;
-        const tabSize = model.getOptions().tabSize;
-        let result = "";
-        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
-            const lineTokens = model.tokenization.getLineTokens(lineNumber);
-            const lineContent = lineTokens.getLineContent();
-            const startOffset = (lineNumber === startLineNumber ? startColumn - 1 : 0);
-            const endOffset = (lineNumber === endLineNumber ? endColumn - 1 : lineContent.length);
-            if (lineContent === "") {
-                result += "<br>";
-            } else {
-                result += tokenizeLineToHTML(
-                    lineContent,
-                    lineTokens.inflate(),
-                    colorMap,
-                    startOffset,
-                    endOffset,
-                    tabSize,
-                    isWindows
-                );
-            }
-        }
-        return EditorTextRenderer._ttPolicy?.createHTML(result) ?? result;
-    }
-    getDefaultColorMap() {
-        const colorMap = TokenizationRegistry.getColorMap();
-        const result = ["#000000"];
-        if (colorMap) {
-            for (let i = 1, len = colorMap.length; i < len; i++) {
-                result[i] = Color.Format.CSS.formatHex(colorMap[i]);
-            }
-        }
-        return result;
-    }
-}
-class CodeCellDragImageRenderer {
-    getDragImage(templateData, editor, type) {
-        let dragImage = this.getDragImageImpl(templateData, editor, type);
-        if (!dragImage) {
-            dragImage = createElement("div");
-            dragImage.textContent = "1 cell";
-        }
-        return dragImage;
-    }
-    getDragImageImpl(templateData, editor, type) {
-        const dragImageContainer = templateData.container.cloneNode(true);
-        dragImageContainer.classList.forEach(c => dragImageContainer.classList.remove(c));
-        dragImageContainer.classList.add("cell-drag-image", "monaco-list-row", "focused", `${type}-cell-row`);
-        const editorContainer = dragImageContainer.querySelector(".cell-editor-container");
-        if (!editorContainer) {
-            return null;
-        }
-        const richEditorText = ( new EditorTextRenderer()).getRichText(editor, ( new Range(1, 1, 1, 1000)));
-        if (!richEditorText) {
-            return null;
-        }
-        reset(editorContainer, richEditorText);
-        return dragImageContainer;
-    }
-}
-
-export { CodeCellDragImageRenderer };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions.d.ts

@@ -1,36 +0,0 @@
-import { Event } from "../../../../../../base/common/event.js";
-import { URI } from "../../../../../../base/common/uri.js";
-import { IEditorOptions } from "../../../../../../editor/common/config/editorOptions.js";
-import { IConfigurationService } from "../../../../../../platform/configuration/common/configuration.service.js";
-import { IBaseCellEditorOptions, ICellViewModel } from "../../notebookBrowser.js";
-import { CellContentPart } from "../cellPart.js";
-import { NotebookCellInternalMetadata } from "../../../common/notebookCommon.js";
-import { NotebookOptions } from "../../notebookOptions.js";
-import { CellViewModelStateChangeEvent } from "../../notebookViewEvents.js";
-import { ITextModelUpdateOptions } from "../../../../../../editor/common/model.js";
-export declare class CellEditorOptions extends CellContentPart implements ITextModelUpdateOptions {
-    private readonly base;
-    readonly notebookOptions: NotebookOptions;
-    readonly configurationService: IConfigurationService;
-    private _lineNumbers;
-    private _tabSize?;
-    private _indentSize?;
-    private _insertSpaces?;
-    set tabSize(value: number | undefined);
-    get tabSize(): number | undefined;
-    set indentSize(value: number | "tabSize" | undefined);
-    get indentSize(): number | "tabSize" | undefined;
-    set insertSpaces(value: boolean | undefined);
-    get insertSpaces(): boolean | undefined;
-    private readonly _onDidChange;
-    readonly onDidChange: Event<void>;
-    private _value;
-    constructor(base: IBaseCellEditorOptions, notebookOptions: NotebookOptions, configurationService: IConfigurationService);
-    updateState(element: ICellViewModel, e: CellViewModelStateChangeEvent): void;
-    private _recomputeOptions;
-    private _computeEditorOptions;
-    getUpdatedValue(internalMetadata: NotebookCellInternalMetadata, cellUri: URI): IEditorOptions;
-    getValue(internalMetadata: NotebookCellInternalMetadata, cellUri: URI): IEditorOptions;
-    getDefaultValue(): IEditorOptions;
-    setLineNumbers(lineNumbers: "on" | "off" | "inherit"): void;
-}