@codingame/monaco-vscode-notebook-service-override 1.85.1

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

@@ -0,0 +1,57 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } 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 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+
+let NotebookUndoRedoContribution = class NotebookUndoRedoContribution extends Disposable {
+    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));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(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 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+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 * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+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 (glob.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,
+    })));
+});