@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

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

@@ -0,0 +1,377 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { expandCellRangesWithHiddenCells } from '../../notebookBrowser.js';
+import { CellContentPart } from '../cellPart.js';
+import { cloneNotebookCellTextModel } from '../../../common/model/notebookCellTextModel.js';
+import { SelectionStateType } from '../../../common/notebookCommon.js';
+import { cellRangesToIndexes } from '../../../common/notebookRange.js';
+const $ = dom.$;
+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 = dom.append(notebookListContainer, $('.cell-list-insertion-indicator'));
+        this._register(dom.addDisposableListener(notebookListContainer.ownerDocument.body, dom.EventType.DRAG_START, this.onGlobalDragStart.bind(this), true));
+        this._register(dom.addDisposableListener(notebookListContainer.ownerDocument.body, dom.EventType.DRAG_END, this.onGlobalDragEnd.bind(this), true));
+        const addCellDragListener = (eventType, handler, useCapture = false) => {
+            this._register(dom.addDisposableListener(notebookEditor.getDomNode(), eventType, e => {
+                const cellDragEvent = this.toCellDragEvent(e);
+                if (cellDragEvent) {
+                    handler(cellDragEvent);
+                }
+            }, useCapture));
+        };
+        addCellDragListener(dom.EventType.DRAG_OVER, event => {
+            if (!this.currentDraggedCell) {
+                return;
+            }
+            event.browserEvent.preventDefault();
+            this.onCellDragover(event);
+        }, true);
+        addCellDragListener(dom.EventType.DROP, event => {
+            if (!this.currentDraggedCell) {
+                return;
+            }
+            event.browserEvent.preventDefault();
+            this.onCellDrop(event);
+        });
+        addCellDragListener(dom.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 && !platform.isMacintosh) || (ctx.altKey && platform.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: 1 ,
+                    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 || !dom.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(dom.addDisposableListener(dragHandle, dom.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(() => cellRoot.parentElement.removeChild(dragImage), 0);
+        };
+        for (const dragHandle of dragHandles) {
+            templateData.templateDisposables.add(dom.addDisposableListener(dragHandle, dom.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: 6 ,
+            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.js

@@ -0,0 +1,97 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { createTrustedTypesPolicy } from 'monaco-editor/esm/vs/base/browser/trustedTypes.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { tokenizeLineToHTML } from 'monaco-editor/esm/vs/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(50 );
+        const fontFamilyVar = '--notebook-editor-font-family';
+        const fontSizeVar = '--notebook-editor-font-size';
+        const fontWeightVar = '--notebook-editor-font-weight';
+        const style = ``
+            + `color: ${colorMap[1 ]};`
+            + `background-color: ${colorMap[2 ]};`
+            + `font-family: var(${fontFamilyVar});`
+            + `font-weight: var(${fontWeightVar});`
+            + `font-size: var(${fontSizeVar});`
+            + `line-height: ${fontInfo.lineHeight}px;`
+            + `white-space: pre;`;
+        const element = dom.$('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, platform.isWindows);
+            }
+        }
+        return EditorTextRenderer._ttPolicy?.createHTML(result) ?? result;
+    }
+    getDefaultColorMap() {
+        const colorMap = languages.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 = document.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;
+        }
+        dom.reset(editorContainer, richEditorText);
+        return dragImageContainer;
+    }
+}
+export { CodeCellDragImageRenderer };

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

@@ -0,0 +1,194 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ActiveEditorContext } from '../../../../../common/contextkeys.js';
+import { NOTEBOOK_ACTIONS_CATEGORY, NotebookMultiCellAction } from '../../controller/coreActions.js';
+import { NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_CELL_LINE_NUMBERS } from '../../../common/notebookContextKeys.js';
+import { CellContentPart } from '../cellPart.js';
+import { NOTEBOOK_EDITOR_ID } from '../../../common/notebookCommon.js';
+class CellEditorOptions extends CellContentPart {
+    constructor(base, notebookOptions, configurationService) {
+        super();
+        this.base = base;
+        this.notebookOptions = notebookOptions;
+        this.configurationService = configurationService;
+        this._lineNumbers = 'inherit';
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(base.onDidChange(() => {
+            this._recomputeOptions();
+        }));
+        this._value = this._computeEditorOptions();
+    }
+    updateState(element, e) {
+        if (e.cellLineNumberChanged) {
+            this.setLineNumbers(element.lineNumbers);
+        }
+    }
+    _recomputeOptions() {
+        this._value = this._computeEditorOptions();
+        this._onDidChange.fire();
+    }
+    _computeEditorOptions() {
+        const value = this.base.value;
+        let cellRenderLineNumber = value.lineNumbers;
+        switch (this._lineNumbers) {
+            case 'inherit':
+                if (this.configurationService.getValue('notebook.lineNumbers') === 'on') {
+                    if (value.lineNumbers === 'off') {
+                        cellRenderLineNumber = 'on';
+                    }
+                }
+                else {
+                    cellRenderLineNumber = 'off';
+                }
+                break;
+            case 'on':
+                if (value.lineNumbers === 'off') {
+                    cellRenderLineNumber = 'on';
+                }
+                break;
+            case 'off':
+                cellRenderLineNumber = 'off';
+                break;
+        }
+        if (value.lineNumbers !== cellRenderLineNumber) {
+            return {
+                ...value,
+                ...{ lineNumbers: cellRenderLineNumber }
+            };
+        }
+        else {
+            return Object.assign({}, value);
+        }
+    }
+    getUpdatedValue(internalMetadata, cellUri) {
+        const options = this.getValue(internalMetadata, cellUri);
+        delete options.hover;
+        return options;
+    }
+    getValue(internalMetadata, cellUri) {
+        return {
+            ...this._value,
+            ...{
+                padding: this.notebookOptions.computeEditorPadding(internalMetadata, cellUri)
+            }
+        };
+    }
+    getDefaultValue() {
+        return {
+            ...this._value,
+            ...{
+                padding: { top: 12, bottom: 12 }
+            }
+        };
+    }
+    setLineNumbers(lineNumbers) {
+        this._lineNumbers = lineNumbers;
+        this._recomputeOptions();
+    }
+}
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: 'notebook',
+    order: 100,
+    type: 'object',
+    'properties': {
+        'notebook.lineNumbers': {
+            type: 'string',
+            enum: ['off', 'on'],
+            default: 'off',
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions',
+                'notebook.lineNumbers',
+                "Controls the display of line numbers in the cell editor."
+            ))
+        }
+    }
+});
+registerAction2(class ToggleLineNumberAction extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.toggleLineNumbers',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions',
+                'notebook.toggleLineNumbers',
+                "Toggle Notebook Line Numbers"
+            )), original: 'Toggle Notebook Line Numbers' },
+            precondition: NOTEBOOK_EDITOR_FOCUSED,
+            menu: [
+                {
+                    id: MenuId.NotebookToolbar,
+                    group: 'notebookLayout',
+                    order: 2,
+                    when: ( ContextKeyExpr.equals('config.notebook.globalToolbar', true))
+                }
+            ],
+            category: NOTEBOOK_ACTIONS_CATEGORY,
+            f1: true,
+            toggled: {
+                condition: ( ContextKeyExpr.notEquals('config.notebook.lineNumbers', 'off')),
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions',
+                    'notebook.showLineNumbers',
+                    "Notebook Line Numbers"
+                )),
+            }
+        });
+    }
+    async run(accessor) {
+        const configurationService = accessor.get(IConfigurationService);
+        const renderLiNumbers = configurationService.getValue('notebook.lineNumbers') === 'on';
+        if (renderLiNumbers) {
+            configurationService.updateValue('notebook.lineNumbers', 'off');
+        }
+        else {
+            configurationService.updateValue('notebook.lineNumbers', 'on');
+        }
+    }
+});
+registerAction2(class ToggleActiveLineNumberAction extends NotebookMultiCellAction {
+    constructor() {
+        super({
+            id: 'notebook.cell.toggleLineNumbers',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions',
+                'notebook.cell.toggleLineNumbers.title',
+                "Show Cell Line Numbers"
+            )),
+            precondition: ( ActiveEditorContext.isEqualTo(NOTEBOOK_EDITOR_ID)),
+            menu: [{
+                    id: MenuId.NotebookCellTitle,
+                    group: 'View',
+                    order: 1
+                }],
+            toggled: ( ContextKeyExpr.or(( NOTEBOOK_CELL_LINE_NUMBERS.isEqualTo('on')), ( ContextKeyExpr.and(( NOTEBOOK_CELL_LINE_NUMBERS.isEqualTo('inherit')), ( ContextKeyExpr.equals('config.notebook.lineNumbers', 'on'))))))
+        });
+    }
+    async runWithContext(accessor, context) {
+        if (context.ui) {
+            this.updateCell(accessor.get(IConfigurationService), context.cell);
+        }
+        else {
+            const configurationService = accessor.get(IConfigurationService);
+            context.selectedCells.forEach(cell => {
+                this.updateCell(configurationService, cell);
+            });
+        }
+    }
+    updateCell(configurationService, cell) {
+        const renderLineNumbers = configurationService.getValue('notebook.lineNumbers') === 'on';
+        const cellLineNumbers = cell.lineNumbers;
+        const currentLineNumberIsOn = cellLineNumbers === 'on' || (cellLineNumbers === 'inherit' && renderLineNumbers);
+        if (currentLineNumberIsOn) {
+            cell.lineNumbers = 'off';
+        }
+        else {
+            cell.lineNumbers = 'on';
+        }
+    }
+});
+export { CellEditorOptions };