@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookKernelView.js

@@ -0,0 +1,173 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { ActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.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 { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { SELECT_KERNEL_ID, NOTEBOOK_ACTIONS_CATEGORY } from '../controller/coreActions.js';
+import { getNotebookEditorFromEditorPane } from '../notebookBrowser.js';
+import { selectKernelIcon } from '../notebookIcons.js';
+import { KernelPickerMRUStrategy } from './notebookKernelQuickPickStrategy.js';
+import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_KERNEL_COUNT } from '../../common/notebookContextKeys.js';
+import { INotebookKernelService, INotebookKernelHistoryService } from '../../common/notebookKernelService.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+function getEditorFromContext(editorService, context) {
+    let editor;
+    if (context !== undefined && 'notebookEditorId' in context) {
+        const editorId = context.notebookEditorId;
+        const matchingEditor = editorService.visibleEditorPanes.find((editorPane) => {
+            const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
+            return notebookEditor?.getId() === editorId;
+        });
+        editor = getNotebookEditorFromEditorPane(matchingEditor);
+    }
+    else if (context !== undefined && 'notebookEditor' in context) {
+        editor = context?.notebookEditor;
+    }
+    else {
+        editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    }
+    return editor;
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SELECT_KERNEL_ID,
+            category: NOTEBOOK_ACTIONS_CATEGORY,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/viewParts/notebookKernelView',
+                'notebookActions.selectKernel',
+                "Select Notebook Kernel"
+            )), original: 'Select Notebook Kernel' },
+            icon: selectKernelIcon,
+            f1: true,
+            precondition: NOTEBOOK_IS_ACTIVE_EDITOR,
+            menu: [{
+                    id: MenuId.EditorTitle,
+                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, ( ContextKeyExpr.notEquals('config.notebook.globalToolbar', true)))),
+                    group: 'navigation',
+                    order: -10
+                }, {
+                    id: MenuId.NotebookToolbar,
+                    when: ( ContextKeyExpr.equals('config.notebook.globalToolbar', true)),
+                    group: 'status',
+                    order: -10
+                }, {
+                    id: MenuId.InteractiveToolbar,
+                    when: ( NOTEBOOK_KERNEL_COUNT.notEqualsTo(0)),
+                    group: 'status',
+                    order: -10
+                }],
+            metadata: {
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/viewParts/notebookKernelView',
+                    'notebookActions.selectKernel.args',
+                    "Notebook Kernel Args"
+                )),
+                args: [
+                    {
+                        name: 'kernelInfo',
+                        description: 'The kernel info',
+                        schema: {
+                            'type': 'object',
+                            'required': ['id', 'extension'],
+                            'properties': {
+                                'id': {
+                                    'type': 'string'
+                                },
+                                'extension': {
+                                    'type': 'string'
+                                },
+                                'notebookEditorId': {
+                                    'type': 'string'
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+        });
+    }
+    async run(accessor, context) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const editorService = accessor.get(IEditorService);
+        const editor = getEditorFromContext(editorService, context);
+        if (!editor || !editor.hasModel()) {
+            return false;
+        }
+        let controllerId = context && 'id' in context ? context.id : undefined;
+        let extensionId = context && 'extension' in context ? context.extension : undefined;
+        if (controllerId && (typeof controllerId !== 'string' || typeof extensionId !== 'string')) {
+            controllerId = undefined;
+            extensionId = undefined;
+        }
+        const notebook = editor.textModel;
+        const notebookKernelService = accessor.get(INotebookKernelService);
+        const matchResult = notebookKernelService.getMatchingKernel(notebook);
+        const { selected } = matchResult;
+        if (selected && controllerId && selected.id === controllerId && ExtensionIdentifier.equals(selected.extension, extensionId)) {
+            return true;
+        }
+        const wantedKernelId = controllerId ? `${extensionId}/${controllerId}` : undefined;
+        const strategy = instantiationService.createInstance(KernelPickerMRUStrategy);
+        return strategy.showQuickPick(editor, wantedKernelId);
+    }
+});
+let NotebooKernelActionViewItem = class NotebooKernelActionViewItem extends ActionViewItem {
+    constructor(actualAction, _editor, _notebookKernelService, _notebookKernelHistoryService) {
+        super(undefined, ( new Action(
+            'fakeAction',
+            undefined,
+            ThemeIcon.asClassName(selectKernelIcon),
+            true,
+            (event) => actualAction.run(event)
+        )), { label: false, icon: true });
+        this._editor = _editor;
+        this._notebookKernelService = _notebookKernelService;
+        this._notebookKernelHistoryService = _notebookKernelHistoryService;
+        this._register(_editor.onDidChangeModel(this._update, this));
+        this._register(_notebookKernelService.onDidAddKernel(this._update, this));
+        this._register(_notebookKernelService.onDidRemoveKernel(this._update, this));
+        this._register(_notebookKernelService.onDidChangeNotebookAffinity(this._update, this));
+        this._register(_notebookKernelService.onDidChangeSelectedNotebooks(this._update, this));
+        this._register(_notebookKernelService.onDidChangeSourceActions(this._update, this));
+        this._register(_notebookKernelService.onDidChangeKernelDetectionTasks(this._update, this));
+    }
+    render(container) {
+        this._update();
+        super.render(container);
+        container.classList.add('kernel-action-view-item');
+        this._kernelLabel = document.createElement('a');
+        container.appendChild(this._kernelLabel);
+        this.updateLabel();
+    }
+    updateLabel() {
+        if (this._kernelLabel) {
+            this._kernelLabel.classList.add('kernel-label');
+            this._kernelLabel.innerText = this._action.label;
+            this._kernelLabel.title = this._action.tooltip;
+        }
+    }
+    _update() {
+        const notebook = this._editor.textModel;
+        if (!notebook) {
+            this._resetAction();
+            return;
+        }
+        KernelPickerMRUStrategy.updateKernelStatusAction(notebook, this._action, this._notebookKernelService, this._notebookKernelHistoryService);
+        this.updateClass();
+    }
+    _resetAction() {
+        this._action.enabled = false;
+        this._action.label = '';
+        this._action.class = '';
+    }
+};
+NotebooKernelActionViewItem = ( __decorate([
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, INotebookKernelHistoryService))
+], NotebooKernelActionViewItem));
+export { NotebooKernelActionViewItem };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookOverviewRuler.js

@@ -0,0 +1,98 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as browser from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { createFastDomNode } from 'monaco-editor/esm/vs/base/browser/fastDomNode.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { NotebookOverviewRulerLane } from '../notebookBrowser.js';
+let NotebookOverviewRuler = class NotebookOverviewRuler extends Themable {
+    constructor(notebookEditor, container, themeService) {
+        super(themeService);
+        this.notebookEditor = notebookEditor;
+        this._lanes = 3;
+        this._domNode = createFastDomNode(document.createElement('canvas'));
+        this._domNode.setPosition('relative');
+        this._domNode.setLayerHinting(true);
+        this._domNode.setContain('strict');
+        container.appendChild(this._domNode.domNode);
+        this._register(notebookEditor.onDidChangeDecorations(() => {
+            this.layout();
+        }));
+        this._register(browser.PixelRatio.onDidChange(() => {
+            this.layout();
+        }));
+    }
+    layout() {
+        const width = 10;
+        const layoutInfo = this.notebookEditor.getLayoutInfo();
+        const scrollHeight = layoutInfo.scrollHeight;
+        const height = layoutInfo.height;
+        const ratio = browser.PixelRatio.value;
+        this._domNode.setWidth(width);
+        this._domNode.setHeight(height);
+        this._domNode.domNode.width = width * ratio;
+        this._domNode.domNode.height = height * ratio;
+        const ctx = this._domNode.domNode.getContext('2d');
+        ctx.clearRect(0, 0, width * ratio, height * ratio);
+        this._render(ctx, width * ratio, height * ratio, scrollHeight * ratio, ratio);
+    }
+    _render(ctx, width, height, scrollHeight, ratio) {
+        const viewModel = this.notebookEditor.getViewModel();
+        const fontInfo = this.notebookEditor.getLayoutInfo().fontInfo;
+        const laneWidth = width / this._lanes;
+        let currentFrom = 0;
+        if (viewModel) {
+            for (let i = 0; i < viewModel.viewCells.length; i++) {
+                const viewCell = viewModel.viewCells[i];
+                const textBuffer = viewCell.textBuffer;
+                const decorations = viewCell.getCellDecorations();
+                const cellHeight = (viewCell.layoutInfo.totalHeight / scrollHeight) * ratio * height;
+                decorations.filter(decoration => decoration.overviewRuler).forEach(decoration => {
+                    const overviewRuler = decoration.overviewRuler;
+                    const fillStyle = this.getColor(overviewRuler.color) ?? '#000000';
+                    const lineHeight = Math.min(fontInfo.lineHeight, (viewCell.layoutInfo.editorHeight / scrollHeight / textBuffer.getLineCount()) * ratio * height);
+                    const lineNumbers = ( overviewRuler.modelRanges.map(range => range.startLineNumber)).reduce((previous, current) => {
+                        if (previous.length === 0) {
+                            previous.push(current);
+                        }
+                        else {
+                            const last = previous[previous.length - 1];
+                            if (last !== current) {
+                                previous.push(current);
+                            }
+                        }
+                        return previous;
+                    }, []);
+                    let x = 0;
+                    switch (overviewRuler.position) {
+                        case NotebookOverviewRulerLane.Left:
+                            x = 0;
+                            break;
+                        case NotebookOverviewRulerLane.Center:
+                            x = laneWidth;
+                            break;
+                        case NotebookOverviewRulerLane.Right:
+                            x = laneWidth * 2;
+                            break;
+                    }
+                    const width = overviewRuler.position === NotebookOverviewRulerLane.Full ? laneWidth * 3 : laneWidth;
+                    for (let i = 0; i < lineNumbers.length; i++) {
+                        ctx.fillStyle = fillStyle;
+                        const lineNumber = lineNumbers[i];
+                        const offset = (lineNumber - 1) * lineHeight;
+                        ctx.fillRect(x, currentFrom + offset, width, lineHeight);
+                    }
+                    if (overviewRuler.includeOutput) {
+                        ctx.fillStyle = fillStyle;
+                        const outputOffset = (viewCell.layoutInfo.editorHeight / scrollHeight) * ratio * height;
+                        const decorationHeight = (fontInfo.lineHeight / scrollHeight) * ratio * height;
+                        ctx.fillRect(laneWidth, currentFrom + outputOffset, laneWidth, decorationHeight);
+                    }
+                });
+                currentFrom += cellHeight;
+            }
+        }
+    }
+};
+NotebookOverviewRuler = ( __decorate([
+    ( __param(2, IThemeService))
+], NotebookOverviewRuler));
+export { NotebookOverviewRuler };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookTopCellToolbar.js

@@ -0,0 +1,62 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MenuWorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { CodiconActionViewItem } from '../view/cellParts/cellActionView.js';
+let ListTopCellToolbar = class ListTopCellToolbar extends Disposable {
+    constructor(notebookEditor, contextKeyService, insertionIndicatorContainer, instantiationService, contextMenuService, menuService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.menuService = menuService;
+        this._modelDisposables = this._register(( new DisposableStore()));
+        this.topCellToolbar = dom.append(insertionIndicatorContainer, dom.$('.cell-list-top-cell-toolbar-container'));
+        this.toolbar = this._register(instantiationService.createInstance(MenuWorkbenchToolBar, this.topCellToolbar, this.notebookEditor.creationOptions.menuIds.cellTopInsertToolbar, {
+            actionViewItemProvider: action => {
+                if (action instanceof MenuItemAction) {
+                    const item = this.instantiationService.createInstance(CodiconActionViewItem, action, undefined);
+                    return item;
+                }
+                return undefined;
+            },
+            menuOptions: {
+                shouldForwardArgs: true
+            },
+            toolbarOptions: {
+                primaryGroup: (g) => /^inline/.test(g),
+            },
+            hiddenItemStrategy: 0 ,
+        }));
+        this.toolbar.context = {
+            notebookEditor
+        };
+        this._register(this.notebookEditor.onDidChangeModel(() => {
+            this._modelDisposables.clear();
+            if (this.notebookEditor.hasModel()) {
+                this._modelDisposables.add(this.notebookEditor.onDidChangeViewCells(() => {
+                    this.updateClass();
+                }));
+                this.updateClass();
+            }
+        }));
+        this.updateClass();
+    }
+    updateClass() {
+        if (this.notebookEditor.hasModel() && this.notebookEditor.getLength() === 0) {
+            this.topCellToolbar.classList.add('emptyNotebook');
+        }
+        else {
+            this.topCellToolbar.classList.remove('emptyNotebook');
+        }
+    }
+};
+ListTopCellToolbar = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IMenuService))
+], ListTopCellToolbar));
+export { ListTopCellToolbar };

package/vscode/src/vs/workbench/contrib/notebook/common/model/notebookCellOutputTextModel.js

@@ -0,0 +1,101 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isTextStreamMime, compressOutputItemStreams } from '../notebookCommon.js';
+class NotebookCellOutputTextModel extends Disposable {
+    get outputs() {
+        return this._rawOutput.outputs || [];
+    }
+    get metadata() {
+        return this._rawOutput.metadata;
+    }
+    get outputId() {
+        return this._rawOutput.outputId;
+    }
+    get alternativeOutputId() {
+        return this._alternativeOutputId;
+    }
+    get versionId() {
+        return this._versionId;
+    }
+    constructor(_rawOutput) {
+        super();
+        this._rawOutput = _rawOutput;
+        this._onDidChangeData = this._register(( new Emitter()));
+        this.onDidChangeData = this._onDidChangeData.event;
+        this._versionId = 0;
+        this.versionedBufferLengths = {};
+        this._alternativeOutputId = this._rawOutput.outputId;
+    }
+    replaceData(rawData) {
+        this.versionedBufferLengths = {};
+        this._rawOutput = rawData;
+        this.optimizeOutputItems();
+        this._versionId = this._versionId + 1;
+        this._onDidChangeData.fire();
+    }
+    appendData(items) {
+        this.trackBufferLengths();
+        this._rawOutput.outputs.push(...items);
+        this.optimizeOutputItems();
+        this._versionId = this._versionId + 1;
+        this._onDidChangeData.fire();
+    }
+    trackBufferLengths() {
+        this.outputs.forEach(output => {
+            if (isTextStreamMime(output.mime)) {
+                if (!this.versionedBufferLengths[output.mime]) {
+                    this.versionedBufferLengths[output.mime] = {};
+                }
+                this.versionedBufferLengths[output.mime][this.versionId] = output.data.byteLength;
+            }
+        });
+    }
+    appendedSinceVersion(versionId, mime) {
+        const bufferLength = this.versionedBufferLengths[mime]?.[versionId];
+        const output = this.outputs.find(output => output.mime === mime);
+        if (bufferLength && output) {
+            return output.data.slice(bufferLength);
+        }
+        return undefined;
+    }
+    optimizeOutputItems() {
+        if (this.outputs.length > 1 && this.outputs.every(item => isTextStreamMime(item.mime))) {
+            const mimeOutputs = ( new Map());
+            const mimeTypes = [];
+            this.outputs.forEach(item => {
+                let items;
+                if (( mimeOutputs.has(item.mime))) {
+                    items = mimeOutputs.get(item.mime);
+                }
+                else {
+                    items = [];
+                    mimeOutputs.set(item.mime, items);
+                    mimeTypes.push(item.mime);
+                }
+                items.push(item.data.buffer);
+            });
+            this.outputs.length = 0;
+            mimeTypes.forEach(mime => {
+                const compressionResult = compressOutputItemStreams(mimeOutputs.get(mime));
+                this.outputs.push({
+                    mime,
+                    data: compressionResult.data
+                });
+                if (compressionResult.didCompression) {
+                    this.versionedBufferLengths = {};
+                }
+            });
+        }
+    }
+    asDto() {
+        return {
+            metadata: this._rawOutput.metadata,
+            outputs: this._rawOutput.outputs,
+            outputId: this._rawOutput.outputId
+        };
+    }
+    bumpVersion() {
+        this._versionId = this._versionId + 1;
+    }
+}
+export { NotebookCellOutputTextModel };