@codingame/monaco-vscode-notebook-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesDataSource.js

@@ -0,0 +1,120 @@
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { variablePageSize } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+
+class NotebookVariableDataSource {
+    constructor(notebookKernelService) {
+        this.notebookKernelService = notebookKernelService;
+        this.cancellationTokenSource = ( new CancellationTokenSource());
+    }
+    hasChildren(element) {
+        return element.kind === 'root' || element.hasNamedChildren || element.indexedChildrenCount > 0;
+    }
+    cancel() {
+        this.cancellationTokenSource.cancel();
+        this.cancellationTokenSource.dispose();
+        this.cancellationTokenSource = ( new CancellationTokenSource());
+    }
+    async getChildren(element) {
+        if (element.kind === 'root') {
+            return this.getRootVariables(element.notebook);
+        }
+        else {
+            return this.getVariables(element);
+        }
+    }
+    async getVariables(parent) {
+        const selectedKernel = this.notebookKernelService.getMatchingKernel(parent.notebook).selected;
+        if (selectedKernel && selectedKernel.hasVariableProvider) {
+            let children = [];
+            if (parent.hasNamedChildren) {
+                const variables = selectedKernel.provideVariables(parent.notebook.uri, parent.extHostId, 'named', 0, this.cancellationTokenSource.token);
+                const childNodes = await ( variables
+                    .map(
+                    variable => { return this.createVariableElement(variable, parent.notebook); }
+                ))
+                    .toPromise();
+                children = children.concat(childNodes);
+            }
+            if (parent.indexedChildrenCount > 0) {
+                const childNodes = await this.getIndexedChildren(parent, selectedKernel);
+                children = children.concat(childNodes);
+            }
+            return children;
+        }
+        return [];
+    }
+    async getIndexedChildren(parent, kernel) {
+        const childNodes = [];
+        if (parent.indexedChildrenCount > variablePageSize) {
+            const nestedPageSize = Math.floor(Math.max(parent.indexedChildrenCount / variablePageSize, 100));
+            const indexedChildCountLimit = 1_000_000;
+            let start = parent.indexStart ?? 0;
+            const last = start + Math.min(parent.indexedChildrenCount, indexedChildCountLimit);
+            for (; start < last; start += nestedPageSize) {
+                let end = start + nestedPageSize;
+                if (end > last) {
+                    end = last;
+                }
+                childNodes.push({
+                    kind: 'variable',
+                    notebook: parent.notebook,
+                    id: parent.id + `${start}`,
+                    extHostId: parent.extHostId,
+                    name: `[${start}..${end - 1}]`,
+                    value: '',
+                    indexedChildrenCount: end - start,
+                    indexStart: start,
+                    hasNamedChildren: false
+                });
+            }
+            if (parent.indexedChildrenCount > indexedChildCountLimit) {
+                childNodes.push({
+                    kind: 'variable',
+                    notebook: parent.notebook,
+                    id: parent.id + `${last + 1}`,
+                    extHostId: parent.extHostId,
+                    name: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesDataSource',
+                        'notebook.indexedChildrenLimitReached',
+                        "Display limit reached"
+                    )),
+                    value: '',
+                    indexedChildrenCount: 0,
+                    hasNamedChildren: false
+                });
+            }
+        }
+        else if (parent.indexedChildrenCount > 0) {
+            const variables = kernel.provideVariables(parent.notebook.uri, parent.extHostId, 'indexed', parent.indexStart ?? 0, this.cancellationTokenSource.token);
+            for await (const variable of variables) {
+                childNodes.push(this.createVariableElement(variable, parent.notebook));
+                if (childNodes.length >= variablePageSize) {
+                    break;
+                }
+            }
+        }
+        return childNodes;
+    }
+    async getRootVariables(notebook) {
+        const selectedKernel = this.notebookKernelService.getMatchingKernel(notebook).selected;
+        if (selectedKernel && selectedKernel.hasVariableProvider) {
+            const variables = selectedKernel.provideVariables(notebook.uri, undefined, 'named', 0, this.cancellationTokenSource.token);
+            return await ( variables
+                .map(variable => { return this.createVariableElement(variable, notebook); }))
+                .toPromise();
+        }
+        return [];
+    }
+    createVariableElement(variable, notebook) {
+        return {
+            ...variable,
+            kind: 'variable',
+            notebook,
+            extHostId: variable.id,
+            id: `${variable.id}`
+        };
+    }
+}
+
+export { NotebookVariableDataSource };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree.js

@@ -0,0 +1,60 @@
+import { append, $ as $$1 } from 'vscode/vscode/vs/base/browser/dom';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import 'vscode/vscode/vs/platform/list/browser/listService';
+import { renderExpressionValue } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
+
+const $ = $$1;
+const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
+class NotebookVariablesDelegate {
+    getHeight(element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        return NotebookVariableRenderer.ID;
+    }
+}
+class NotebookVariableRenderer {
+    static { this.ID = 'variableElement'; }
+    get templateId() {
+        return NotebookVariableRenderer.ID;
+    }
+    renderTemplate(container) {
+        const expression = append(container, $('.expression'));
+        const name = append(expression, $('span.name'));
+        const value = append(expression, $('span.value'));
+        const template = { expression, name, value };
+        return template;
+    }
+    renderElement(element, _index, data) {
+        const text = element.element.value.trim() !== '' ? `${element.element.name}:` : element.element.name;
+        data.name.textContent = text;
+        data.name.title = element.element.type ?? '';
+        renderExpressionValue(element.element, data.value, {
+            colorize: true,
+            showHover: true,
+            maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET
+        });
+    }
+    disposeTemplate() {
+    }
+}
+class NotebookVariableAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree',
+            'debugConsole',
+            "Notebook Variables"
+        ));
+    }
+    getAriaLabel(element) {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree',
+            'notebookVariableAriaLabel',
+            "Variable {0}, value {1}",
+            element.name,
+            element.value
+        ));
+    }
+}
+
+export { NotebookVariableAccessibilityProvider, NotebookVariableRenderer, NotebookVariablesDelegate };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesView.js

@@ -0,0 +1,150 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuId, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { CONTEXT_VARIABLE_NAME, CONTEXT_VARIABLE_VALUE, CONTEXT_VARIABLE_TYPE, CONTEXT_VARIABLE_INTERFACES, CONTEXT_VARIABLE_LANGUAGE, CONTEXT_VARIABLE_EXTENSIONID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { NotebookVariableDataSource } from './notebookVariablesDataSource.js';
+import { NotebookVariablesDelegate, NotebookVariableRenderer, NotebookVariableAccessibilityProvider } from './notebookVariablesTree.js';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
+    static { this.ID = 'notebookVariablesView'; }
+    static { this.TITLE = ( localize2WithPath(
+        'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesView',
+        'notebook.notebookVariables',
+        "Notebook Variables"
+    )); }
+    constructor(options, editorService, notebookKernelService, notebookExecutionStateService, keybindingService, contextMenuService, contextKeyService, configurationService, instantiationService, viewDescriptorService, openerService, quickInputService, commandService, themeService, telemetryService, menuService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.editorService = editorService;
+        this.notebookKernelService = notebookKernelService;
+        this.notebookExecutionStateService = notebookExecutionStateService;
+        this.quickInputService = quickInputService;
+        this.commandService = commandService;
+        this.menuService = menuService;
+        this._register(this.editorService.onDidActiveEditorChange(this.handleActiveEditorChange.bind(this)));
+        this._register(this.notebookKernelService.onDidNotebookVariablesUpdate(this.handleVariablesChanged.bind(this)));
+        this._register(this.notebookExecutionStateService.onDidChangeExecution(this.handleExecutionStateChange.bind(this)));
+        this.setActiveNotebook();
+        this.dataSource = ( new NotebookVariableDataSource(this.notebookKernelService));
+        this.updateScheduler = ( new RunOnceScheduler(() => this.tree?.updateChildren(), 100));
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.element.classList.add('debug-pane');
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'notebookVariablesTree', container, ( new NotebookVariablesDelegate()), [( new NotebookVariableRenderer())], this.dataSource, {
+            accessibilityProvider: ( new NotebookVariableAccessibilityProvider()),
+            identityProvider: { getId: (e) => e.id },
+        });
+        this.tree.layout();
+        if (this.activeNotebook) {
+            this.tree.setInput({ kind: 'root', notebook: this.activeNotebook });
+        }
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
+    }
+    onContextMenu(e) {
+        if (!e.element) {
+            return;
+        }
+        const element = e.element;
+        const arg = {
+            source: ( element.notebook.uri.toString()),
+            name: element.name,
+            value: element.value,
+            type: element.type,
+            expression: element.expression,
+            language: element.language,
+            extensionId: element.extensionId
+        };
+        const actions = [];
+        const overlayedContext = this.contextKeyService.createOverlay([
+            [CONTEXT_VARIABLE_NAME.key, element.name],
+            [CONTEXT_VARIABLE_VALUE.key, element.value],
+            [CONTEXT_VARIABLE_TYPE.key, element.type],
+            [CONTEXT_VARIABLE_INTERFACES.key, element.interfaces],
+            [CONTEXT_VARIABLE_LANGUAGE.key, element.language],
+            [CONTEXT_VARIABLE_EXTENSIONID.key, element.extensionId]
+        ]);
+        const menu = this.menuService.createMenu(MenuId.NotebookVariablesContext, overlayedContext);
+        createAndFillInContextMenuActions(menu, { arg, shouldForwardArgs: true }, actions);
+        menu.dispose();
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => actions
+        });
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.tree?.layout(height, width);
+    }
+    setActiveNotebook() {
+        const current = this.activeNotebook;
+        const activeEditorPane = this.editorService.activeEditorPane;
+        if (activeEditorPane?.getId() === 'workbench.editor.notebook' || activeEditorPane?.getId() === 'workbench.editor.interactive') {
+            const notebookDocument = getNotebookEditorFromEditorPane(activeEditorPane)?.getViewModel()?.notebookDocument;
+            this.activeNotebook = notebookDocument;
+        }
+        return current !== this.activeNotebook;
+    }
+    handleActiveEditorChange() {
+        if (this.setActiveNotebook() && this.activeNotebook) {
+            this.tree?.setInput({ kind: 'root', notebook: this.activeNotebook });
+            this.updateScheduler.schedule();
+        }
+    }
+    handleExecutionStateChange(event) {
+        if (this.activeNotebook) {
+            if (event.affectsNotebook(this.activeNotebook.uri)) {
+                this.dataSource.cancel();
+                if (event.changed === undefined) {
+                    this.updateScheduler.schedule();
+                }
+                else {
+                    this.updateScheduler.cancel();
+                }
+            }
+        }
+    }
+    handleVariablesChanged(notebookUri) {
+        if (this.activeNotebook && ( notebookUri.toString()) === ( this.activeNotebook.uri.toString())) {
+            this.tree?.setInput({ kind: 'root', notebook: this.activeNotebook });
+            this.updateScheduler.schedule();
+        }
+    }
+};
+NotebookVariablesView = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, INotebookExecutionStateService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, IQuickInputService)),
+    ( __param(12, ICommandService)),
+    ( __param(13, IThemeService)),
+    ( __param(14, ITelemetryService)),
+    ( __param(15, IMenuService))
+], NotebookVariablesView));
+
+export { NotebookVariablesView };