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

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout.js

@@ -0,0 +1,159 @@
+import { Disposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+class TroubleshootController extends Disposable {
+    static { this.id = 'workbench.notebook.troubleshoot'; }
+    constructor(_notebookEditor) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._localStore = this._register(( new DisposableStore()));
+        this._cellStateListeners = [];
+        this._enabled = false;
+        this._cellStatusItems = [];
+        this._register(this._notebookEditor.onDidChangeModel(() => {
+            this._update();
+        }));
+        this._update();
+    }
+    toggle() {
+        this._enabled = !this._enabled;
+        this._update();
+    }
+    _update() {
+        this._localStore.clear();
+        this._cellStateListeners.forEach(listener => listener.dispose());
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        this._updateListener();
+    }
+    _log(cell, e) {
+        if (this._enabled) {
+            const oldHeight = this._notebookEditor.getViewHeight(cell);
+            console.log(`cell#${cell.handle}`, e, `${oldHeight} -> ${cell.layoutInfo.totalHeight}`);
+        }
+    }
+    _updateListener() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        for (let i = 0; i < this._notebookEditor.getLength(); i++) {
+            const cell = this._notebookEditor.cellAt(i);
+            this._cellStateListeners.push(cell.onDidChangeLayout(e => {
+                this._log(cell, e);
+            }));
+        }
+        this._localStore.add(this._notebookEditor.onDidChangeViewCells(e => {
+            [...e.splices].reverse().forEach(splice => {
+                const [start, deleted, newCells] = splice;
+                const deletedCells = this._cellStateListeners.splice(start, deleted, ...( newCells.map(cell => {
+                    return cell.onDidChangeLayout((e) => {
+                        this._log(cell, e);
+                    });
+                })));
+                dispose(deletedCells);
+            });
+        }));
+        const vm = this._notebookEditor.getViewModel();
+        let items = [];
+        if (this._enabled) {
+            items = this._getItemsForCells();
+        }
+        this._cellStatusItems = vm.deltaCellStatusBarItems(this._cellStatusItems, items);
+    }
+    _getItemsForCells() {
+        const items = [];
+        for (let i = 0; i < this._notebookEditor.getLength(); i++) {
+            items.push({
+                handle: i,
+                items: [
+                    {
+                        text: `index: ${i}`,
+                        alignment: 1 ,
+                        priority: Number.MAX_SAFE_INTEGER
+                    }
+                ]
+            });
+        }
+        return items;
+    }
+    dispose() {
+        dispose(this._cellStateListeners);
+        super.dispose();
+    }
+}
+registerNotebookContribution(TroubleshootController.id, TroubleshootController);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.toggleLayoutTroubleshoot',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
+                'workbench.notebook.toggleLayoutTroubleshoot',
+                "Toggle Layout Troubleshoot"
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(TroubleshootController.id);
+        controller?.toggle();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.inspectLayout',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
+                'workbench.notebook.inspectLayout',
+                "Inspect Notebook Layout"
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor || !editor.hasModel()) {
+            return;
+        }
+        for (let i = 0; i < editor.getLength(); i++) {
+            const cell = editor.cellAt(i);
+            console.log(`cell#${cell.handle}`, cell.layoutInfo);
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.clearNotebookEdtitorTypeCache',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
+                'workbench.notebook.clearNotebookEdtitorTypeCache',
+                "Clear Notebook Editor Type Cache"
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const notebookService = accessor.get(INotebookService);
+        notebookService.clearEditorCache();
+    }
+});
+
+export { TroubleshootController };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/undoRedo/notebookUndoRedo.js

@@ -0,0 +1,56 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { getNotebookEditorFromEditorPane, CellEditState } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { UndoCommand, RedoCommand } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+
+let NotebookUndoRedoContribution = class NotebookUndoRedoContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.notebookUndoRedo'; }
+    constructor(_editorService) {
+        super();
+        this._editorService = _editorService;
+        const PRIORITY = 105;
+        this._register(UndoCommand.addImplementation(PRIORITY, 'notebook-undo-redo', () => {
+            const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+            const viewModel = editor?.getViewModel();
+            if (editor && editor.hasModel() && viewModel) {
+                return viewModel.undo().then(cellResources => {
+                    if (cellResources?.length) {
+                        for (let i = 0; i < editor.getLength(); i++) {
+                            const cell = editor.cellAt(i);
+                            if (cell.cellKind === CellKind.Markup && cellResources.find(resource => resource.fragment === cell.model.uri.fragment)) {
+                                cell.updateEditState(CellEditState.Editing, 'undo');
+                            }
+                        }
+                        editor?.setOptions({ cellOptions: { resource: cellResources[0] }, preserveFocus: true });
+                    }
+                });
+            }
+            return false;
+        }));
+        this._register(RedoCommand.addImplementation(PRIORITY, 'notebook-undo-redo', () => {
+            const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+            const viewModel = editor?.getViewModel();
+            if (editor && editor.hasModel() && viewModel) {
+                return viewModel.redo().then(cellResources => {
+                    if (cellResources?.length) {
+                        for (let i = 0; i < editor.getLength(); i++) {
+                            const cell = editor.cellAt(i);
+                            if (cell.cellKind === CellKind.Markup && cellResources.find(resource => resource.fragment === cell.model.uri.fragment)) {
+                                cell.updateEditState(CellEditState.Editing, 'redo');
+                            }
+                        }
+                        editor?.setOptions({ cellOptions: { resource: cellResources[0] }, preserveFocus: true });
+                    }
+                });
+            }
+            return false;
+        }));
+    }
+};
+NotebookUndoRedoContribution = ( __decorate([
+    ( __param(0, IEditorService))
+], NotebookUndoRedoContribution));
+registerWorkbenchContribution2(NotebookUndoRedoContribution.ID, NotebookUndoRedoContribution, 2 );

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/viewportWarmup/viewportWarmup.js

@@ -0,0 +1,94 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
+import { CellEditState } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { outputDisplayLimit } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel';
+import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { cellRangesToIndexes } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookRange';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+
+let NotebookViewportContribution = class NotebookViewportContribution extends Disposable {
+    static { this.id = 'workbench.notebook.viewportWarmup'; }
+    constructor(_notebookEditor, _notebookService, accessibilityService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._notebookService = _notebookService;
+        this._warmupDocument = null;
+        this._warmupViewport = ( new RunOnceScheduler(() => this._warmupViewportNow(), 200));
+        this._register(this._warmupViewport);
+        this._register(this._notebookEditor.onDidScroll(() => {
+            this._warmupViewport.schedule();
+        }));
+        this._warmupDocument = ( new RunOnceScheduler(() => this._warmupDocumentNow(), 200));
+        this._register(this._warmupDocument);
+        this._register(this._notebookEditor.onDidAttachViewModel(() => {
+            if (this._notebookEditor.hasModel()) {
+                this._warmupDocument?.schedule();
+            }
+        }));
+        if (this._notebookEditor.hasModel()) {
+            this._warmupDocument?.schedule();
+        }
+    }
+    _warmupDocumentNow() {
+        if (this._notebookEditor.hasModel()) {
+            for (let i = 0; i < this._notebookEditor.getLength(); i++) {
+                const cell = this._notebookEditor.cellAt(i);
+                if (cell?.cellKind === CellKind.Markup && cell?.getEditState() === CellEditState.Preview && !cell.isInputCollapsed) ;
+                else if (cell?.cellKind === CellKind.Code) {
+                    this._warmupCodeCell(cell);
+                }
+            }
+        }
+    }
+    _warmupViewportNow() {
+        if (this._notebookEditor.isDisposed) {
+            return;
+        }
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        const visibleRanges = this._notebookEditor.getVisibleRangesPlusViewportAboveAndBelow();
+        cellRangesToIndexes(visibleRanges).forEach(index => {
+            const cell = this._notebookEditor.cellAt(index);
+            if (cell?.cellKind === CellKind.Markup && cell?.getEditState() === CellEditState.Preview && !cell.isInputCollapsed) {
+                this._notebookEditor.createMarkupPreview(cell);
+            }
+            else if (cell?.cellKind === CellKind.Code) {
+                this._warmupCodeCell(cell);
+            }
+        });
+    }
+    _warmupCodeCell(viewCell) {
+        if (viewCell.isOutputCollapsed) {
+            return;
+        }
+        const outputs = viewCell.outputsViewModels;
+        for (const output of outputs.slice(0, outputDisplayLimit)) {
+            const [mimeTypes, pick] = output.resolveMimeTypes(this._notebookEditor.textModel, undefined);
+            if (!mimeTypes.find(mimeType => mimeType.isTrusted) || mimeTypes.length === 0) {
+                continue;
+            }
+            const pickedMimeTypeRenderer = mimeTypes[pick];
+            if (!pickedMimeTypeRenderer) {
+                return;
+            }
+            if (!this._notebookEditor.hasModel()) {
+                return;
+            }
+            const renderer = this._notebookService.getRendererInfo(pickedMimeTypeRenderer.rendererId);
+            if (!renderer) {
+                return;
+            }
+            const result = { type: 1 , renderer, source: output, mimeType: pickedMimeTypeRenderer.mimeType };
+            this._notebookEditor.createOutput(viewCell, result, 0, true);
+        }
+    }
+};
+NotebookViewportContribution = ( __decorate([
+    ( __param(1, INotebookService)),
+    ( __param(2, IAccessibilityService))
+], NotebookViewportContribution));
+registerNotebookContribution(NotebookViewportContribution.id, NotebookViewportContribution);

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/apiActions.js

@@ -0,0 +1,51 @@
+import { isRelativePattern } from 'vscode/vscode/vs/base/common/glob';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { isDocumentExcludePattern } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+
+CommandsRegistry.registerCommand('_resolveNotebookContentProvider', (accessor) => {
+    const notebookService = accessor.get(INotebookService);
+    const contentProviders = notebookService.getContributedNotebookTypes();
+    return ( contentProviders.map(provider => {
+        const filenamePatterns = ( provider.selectors.map(selector => {
+            if (typeof selector === 'string') {
+                return selector;
+            }
+            if (isRelativePattern(selector)) {
+                return selector;
+            }
+            if (isDocumentExcludePattern(selector)) {
+                return {
+                    include: selector.include,
+                    exclude: selector.exclude
+                };
+            }
+            return null;
+        })).filter(pattern => pattern !== null);
+        return {
+            viewType: provider.id,
+            displayName: provider.displayName,
+            filenamePattern: filenamePatterns,
+            options: {
+                transientCellMetadata: provider.options.transientCellMetadata,
+                transientDocumentMetadata: provider.options.transientDocumentMetadata,
+                transientOutputs: provider.options.transientOutputs
+            }
+        };
+    }));
+});
+CommandsRegistry.registerCommand('_resolveNotebookKernels', async (accessor, args) => {
+    const notebookKernelService = accessor.get(INotebookKernelService);
+    const uri = URI.revive(args.uri);
+    const kernels = notebookKernelService.getMatchingKernel({ uri, viewType: args.viewType });
+    return ( kernels.all.map(provider => ({
+        id: provider.id,
+        label: provider.label,
+        description: provider.description,
+        detail: provider.detail,
+        isPreferred: false,
+        preloads: provider.preloadUris,
+    })));
+});