@codingame/monaco-vscode-notebook-service-override 37.1.0 → 37.3.0

package/index.js

@@ -30,14 +30,19 @@ import { NotebookDocumentWorkbenchService } from '@codingame/monaco-vscode-api/v
 import { INotebookDocumentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service';
 import { INotebookOriginalCellModelFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookOriginalCellModelFactory.service';
 import { INotebookOriginalModelReferenceFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookOriginalModelRefFactory.service';
-import { OriginalNotebookCellModelFactory } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookOriginalCellModelFactory';
-import { NotebookOriginalModelReferenceFactory } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookOriginalModelRefFactory';
+import { OriginalNotebookCellModelFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookOriginalCellModelFactory';
+import { NotebookOriginalModelReferenceFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookOriginalModelRefFactory';
 import { INotebookCellOutlineDataSourceFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSourceFactory.service';
 import { NotebookCellOutlineDataSourceFactory } from './vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSourceFactory.js';
 import { NotebookOutlineEntryFactory } from './vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory.js';
 import { INotebookOutlineEntryFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory.service';
 import './vscode/src/vs/workbench/contrib/replNotebook/browser/repl.contribution.js';
 import './vscode/src/vs/workbench/contrib/notebook/browser/notebook.contribution.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadNotebook.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadNotebookKernels.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadNotebookDocumentsAndEditors.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadNotebookRenderers.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadNotebookSaveParticipant.js';
 
 function getServiceOverride() {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-notebook-service-override",
-  "version": "37.1.0",
+  "version": "37.3.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - notebook service-override",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "37.1.0",
-    "@codingame/monaco-vscode-katex-common": "37.1.0"
+    "@codingame/monaco-vscode-api": "37.3.0",
+    "@codingame/monaco-vscode-katex-common": "37.3.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/workbench/api/browser/mainThreadNotebook.d.ts

@@ -0,0 +1,22 @@
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotebookCellStatusBarService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService.service";
+import { INotebookContributionData, NotebookExtensionDescription, TransientOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { MainThreadNotebookShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadNotebooks implements MainThreadNotebookShape {
+    private readonly _notebookService;
+    private readonly _cellStatusBarService;
+    private readonly _logService;
+    private readonly _disposables;
+    private readonly _proxy;
+    private readonly _notebookSerializer;
+    private readonly _notebookCellStatusBarRegistrations;
+    constructor(extHostContext: IExtHostContext, _notebookService: INotebookService, _cellStatusBarService: INotebookCellStatusBarService, _logService: ILogService);
+    dispose(): void;
+    $registerNotebookSerializer(handle: number, extension: NotebookExtensionDescription, viewType: string, options: TransientOptions, data: INotebookContributionData | undefined): void;
+    $unregisterNotebookSerializer(handle: number): void;
+    $emitCellStatusBarEvent(eventHandle: number): void;
+    $registerNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined, viewType: string): Promise<void>;
+    $unregisterNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined): Promise<void>;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadNotebook.js

@@ -0,0 +1,210 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { NotebookDto } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+import { INotebookCellStatusBarService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService.service';
+import { SimpleNotebookProviderInfo } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { SerializableObjectWithBuffers } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { FileOperationError } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+
+let MainThreadNotebooks = class MainThreadNotebooks {
+    constructor(extHostContext, _notebookService, _cellStatusBarService, _logService) {
+        this._notebookService = _notebookService;
+        this._cellStatusBarService = _cellStatusBarService;
+        this._logService = _logService;
+        this._disposables = ( new DisposableStore());
+        this._notebookSerializer = ( new Map());
+        this._notebookCellStatusBarRegistrations = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebook));
+    }
+    dispose() {
+        this._disposables.dispose();
+        dispose(( this._notebookSerializer.values()));
+        dispose(( this._notebookCellStatusBarRegistrations.values()));
+        this._notebookCellStatusBarRegistrations.clear();
+    }
+    $registerNotebookSerializer(handle, extension, viewType, options, data) {
+        const disposables = ( new DisposableStore());
+        disposables.add(this._notebookService.registerNotebookSerializer(viewType, extension, {
+            options,
+            dataToNotebook: async data => {
+                const sw = ( new StopWatch());
+                let result;
+                if (data.byteLength === 0 && viewType === "interactive") {
+                    result = NotebookDto.fromNotebookDataDto({
+                        cells: [],
+                        metadata: {}
+                    });
+                } else {
+                    const dto = await this._proxy.$dataToNotebook(handle, data, CancellationToken.None);
+                    result = NotebookDto.fromNotebookDataDto(dto.value);
+                }
+                this._logService.trace(`[NotebookSerializer] dataToNotebook DONE after ${sw.elapsed()}ms`, {
+                    viewType,
+                    extensionId: extension.id.value
+                });
+                return result;
+            },
+            notebookToData: data => {
+                const sw = ( new StopWatch());
+                const result = this._proxy.$notebookToData(handle, ( new SerializableObjectWithBuffers(NotebookDto.toNotebookDataDto(data))), CancellationToken.None);
+                this._logService.trace(`[NotebookSerializer] notebookToData DONE after ${sw.elapsed()}`, {
+                    viewType,
+                    extensionId: extension.id.value
+                });
+                return result;
+            },
+            save: async (uri, versionId, options, token) => {
+                const stat = await this._proxy.$saveNotebook(handle, uri, versionId, options, token);
+                if (isFileOperationError(stat)) {
+                    throw ( new FileOperationError(stat.message, stat.fileOperationResult, stat.options));
+                }
+                return {
+                    ...stat,
+                    children: undefined,
+                    resource: uri
+                };
+            },
+            searchInNotebooks: async (textQuery, token, allPriorityInfo) => {
+                const contributedType = this._notebookService.getContributedNotebookType(viewType);
+                if (!contributedType) {
+                    return {
+                        results: [],
+                        limitHit: false
+                    };
+                }
+                const fileNames = contributedType.selectors;
+                const includes = fileNames.map(selector => {
+                    const globPattern = selector.include || selector;
+                    return ( globPattern.toString());
+                });
+                if (!includes.length) {
+                    return {
+                        results: [],
+                        limitHit: false
+                    };
+                }
+                const thisPriorityInfo = coalesce([{
+                    isFromSettings: false,
+                    filenamePatterns: includes
+                }, ...(allPriorityInfo.get(viewType) ?? [])]);
+                const otherEditorsPriorityInfo = Array.from(( allPriorityInfo.keys())).flatMap(key => {
+                    if (key !== viewType) {
+                        return allPriorityInfo.get(key) ?? [];
+                    }
+                    return [];
+                });
+                const searchComplete = await this._proxy.$searchInNotebooks(handle, textQuery, thisPriorityInfo, otherEditorsPriorityInfo, token);
+                const revivedResults = searchComplete.results.map(result => {
+                    const resource = URI.revive(result.resource);
+                    return {
+                        resource,
+                        cellResults: result.cellResults.map(e => revive(e))
+                    };
+                });
+                return {
+                    results: revivedResults,
+                    limitHit: searchComplete.limitHit
+                };
+            }
+        }));
+        if (data) {
+            disposables.add(this._notebookService.registerContributedNotebookType(viewType, data));
+        }
+        this._notebookSerializer.set(handle, disposables);
+        this._logService.trace("[NotebookSerializer] registered notebook serializer", {
+            viewType,
+            extensionId: extension.id.value
+        });
+    }
+    $unregisterNotebookSerializer(handle) {
+        this._notebookSerializer.get(handle)?.dispose();
+        this._notebookSerializer.delete(handle);
+    }
+    $emitCellStatusBarEvent(eventHandle) {
+        const emitter = this._notebookCellStatusBarRegistrations.get(eventHandle);
+        if (emitter instanceof Emitter) {
+            emitter.fire(undefined);
+        }
+    }
+    async $registerNotebookCellStatusBarItemProvider(handle, eventHandle, viewType) {
+        const that = this;
+        const provider = {
+            async provideCellStatusBarItems(uri, index, token) {
+                const result = await that._proxy.$provideNotebookCellStatusBarItems(handle, uri, index, token);
+                return {
+                    items: result?.items ?? [],
+                    dispose() {
+                        if (result) {
+                            that._proxy.$releaseNotebookCellStatusBarItems(result.cacheId);
+                        }
+                    }
+                };
+            },
+            viewType
+        };
+        if (typeof eventHandle === "number") {
+            const emitter = ( new Emitter());
+            this._notebookCellStatusBarRegistrations.set(eventHandle, emitter);
+            provider.onDidChangeStatusBarItems = emitter.event;
+        }
+        const disposable = this._cellStatusBarService.registerCellStatusBarItemProvider(provider);
+        this._notebookCellStatusBarRegistrations.set(handle, disposable);
+    }
+    async $unregisterNotebookCellStatusBarItemProvider(handle, eventHandle) {
+        const unregisterThing = handle => {
+            const entry = this._notebookCellStatusBarRegistrations.get(handle);
+            if (entry) {
+                this._notebookCellStatusBarRegistrations.get(handle)?.dispose();
+                this._notebookCellStatusBarRegistrations.delete(handle);
+            }
+        };
+        unregisterThing(handle);
+        if (typeof eventHandle === "number") {
+            unregisterThing(eventHandle);
+        }
+    }
+};
+MainThreadNotebooks = __decorate([extHostNamedCustomer(MainContext.MainThreadNotebook), ( __param(1, INotebookService)), ( __param(2, INotebookCellStatusBarService)), ( __param(3, ILogService))], MainThreadNotebooks);
+CommandsRegistry.registerCommand("_executeDataToNotebook", async (accessor, ...args) => {
+    const [notebookType, bytes] = args;
+    assertType(typeof notebookType === "string", "string");
+    assertType(bytes instanceof VSBuffer, "VSBuffer");
+    const notebookService = accessor.get(INotebookService);
+    const info = await notebookService.withNotebookDataProvider(notebookType);
+    if (!(info instanceof SimpleNotebookProviderInfo)) {
+        return;
+    }
+    const dto = await info.serializer.dataToNotebook(bytes);
+    return ( new SerializableObjectWithBuffers(NotebookDto.toNotebookDataDto(dto)));
+});
+CommandsRegistry.registerCommand("_executeNotebookToData", async (accessor, notebookType, dto) => {
+    assertType(typeof notebookType === "string", "string");
+    const notebookService = accessor.get(INotebookService);
+    const info = await notebookService.withNotebookDataProvider(notebookType);
+    if (!(info instanceof SimpleNotebookProviderInfo)) {
+        return;
+    }
+    const data = NotebookDto.fromNotebookDataDto(dto.value);
+    const bytes = await info.serializer.notebookToData(data);
+    return bytes;
+});
+function isFileOperationError(error) {
+    const candidate = error;
+    return typeof candidate?.fileOperationResult === "number" && typeof candidate?.message === "string";
+}
+
+export { MainThreadNotebooks };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDocuments.d.ts

@@ -0,0 +1,24 @@
+import { URI, UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { NotebookTextModel } from "../../contrib/notebook/common/model/notebookTextModel.js";
+import { INotebookEditorModelResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { MainThreadNotebookDocumentsShape, NotebookDataDto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+export declare class MainThreadNotebookDocuments implements MainThreadNotebookDocumentsShape {
+    private readonly _notebookEditorModelResolverService;
+    private readonly _uriIdentityService;
+    private readonly _disposables;
+    private readonly _proxy;
+    private readonly _documentEventListenersMapping;
+    private readonly _modelReferenceCollection;
+    constructor(extHostContext: IExtHostContext, _notebookEditorModelResolverService: INotebookEditorModelResolverService, _uriIdentityService: IUriIdentityService);
+    dispose(): void;
+    handleNotebooksAdded(notebooks: readonly NotebookTextModel[]): void;
+    handleNotebooksRemoved(uris: URI[]): void;
+    $tryCreateNotebook(options: {
+        viewType: string;
+        content?: NotebookDataDto;
+    }): Promise<UriComponents>;
+    $tryOpenNotebook(uriComponents: UriComponents): Promise<URI>;
+    $trySaveNotebook(uriComponents: UriComponents): Promise<boolean>;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDocuments.js

@@ -0,0 +1,140 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { BoundModelReferenceCollection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadDocuments';
+import { NotebookCellsChangeType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { ExtHostContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { NotebookDto } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+import { SerializableObjectWithBuffers } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
+    constructor(extHostContext, _notebookEditorModelResolverService, _uriIdentityService) {
+        this._notebookEditorModelResolverService = _notebookEditorModelResolverService;
+        this._uriIdentityService = _uriIdentityService;
+        this._disposables = ( new DisposableStore());
+        this._documentEventListenersMapping = ( new ResourceMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocuments));
+        this._modelReferenceCollection = ( new BoundModelReferenceCollection(this._uriIdentityService.extUri));
+        this._disposables.add(this._notebookEditorModelResolverService.onDidChangeDirty(
+            model => this._proxy.$acceptDirtyStateChanged(model.resource, model.isDirty())
+        ));
+        this._disposables.add(
+            this._notebookEditorModelResolverService.onDidSaveNotebook(e => this._proxy.$acceptModelSaved(e))
+        );
+        this._disposables.add(_notebookEditorModelResolverService.onWillFailWithConflict(e => {
+            this._modelReferenceCollection.remove(e.resource);
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._modelReferenceCollection.dispose();
+        dispose(( this._documentEventListenersMapping.values()));
+    }
+    handleNotebooksAdded(notebooks) {
+        for (const textModel of notebooks) {
+            const disposableStore = ( new DisposableStore());
+            disposableStore.add(textModel.onDidChangeContent(event => {
+                const eventDto = {
+                    versionId: event.versionId,
+                    rawEvents: []
+                };
+                for (const e of event.rawEvents) {
+                    switch (e.kind) {
+                    case NotebookCellsChangeType.ModelChange:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            changes: e.changes.map(
+                                diff => [diff[0], diff[1], diff[2].map(cell => NotebookDto.toNotebookCellDto(cell))]
+                            )
+                        });
+                        break;
+                    case NotebookCellsChangeType.Move:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            index: e.index,
+                            length: e.length,
+                            newIdx: e.newIdx
+                        });
+                        break;
+                    case NotebookCellsChangeType.Output:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            index: e.index,
+                            outputs: e.outputs.map(NotebookDto.toNotebookOutputDto)
+                        });
+                        break;
+                    case NotebookCellsChangeType.OutputItem:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            index: e.index,
+                            outputId: e.outputId,
+                            outputItems: e.outputItems.map(NotebookDto.toNotebookOutputItemDto),
+                            append: e.append
+                        });
+                        break;
+                    case NotebookCellsChangeType.ChangeCellLanguage:
+                    case NotebookCellsChangeType.ChangeCellContent:
+                    case NotebookCellsChangeType.ChangeCellMetadata:
+                    case NotebookCellsChangeType.ChangeCellInternalMetadata:
+                        eventDto.rawEvents.push(e);
+                        break;
+                    }
+                }
+                const hasDocumentMetadataChangeEvent = event.rawEvents.find(e => e.kind === NotebookCellsChangeType.ChangeDocumentMetadata);
+                this._proxy.$acceptModelChanged(textModel.uri, ( new SerializableObjectWithBuffers(eventDto)), this._notebookEditorModelResolverService.isDirty(textModel.uri), hasDocumentMetadataChangeEvent ? textModel.metadata : undefined);
+            }));
+            this._documentEventListenersMapping.set(textModel.uri, disposableStore);
+        }
+    }
+    handleNotebooksRemoved(uris) {
+        for (const uri of uris) {
+            this._documentEventListenersMapping.get(uri)?.dispose();
+            this._documentEventListenersMapping.delete(uri);
+        }
+    }
+    async $tryCreateNotebook(options) {
+        if (options.content) {
+            const ref = await this._notebookEditorModelResolverService.resolve({
+                untitledResource: undefined
+            }, options.viewType);
+            Event.once(ref.object.notebook.onWillDispose)(() => {
+                ref.dispose();
+            });
+            this._proxy.$acceptDirtyStateChanged(ref.object.resource, true);
+            if (options.content) {
+                const data = NotebookDto.fromNotebookDataDto(options.content);
+                ref.object.notebook.reset(data.cells, data.metadata, ref.object.notebook.transientOptions);
+            }
+            return ref.object.notebook.uri;
+        } else {
+            const notebook = await this._notebookEditorModelResolverService.createUntitledNotebookTextModel(options.viewType);
+            return notebook.uri;
+        }
+    }
+    async $tryOpenNotebook(uriComponents) {
+        const uri = URI.revive(uriComponents);
+        const ref = await this._notebookEditorModelResolverService.resolve(uri, undefined);
+        if (uriComponents.scheme === "untitled") {
+            ref.object.notebook.onWillDispose(() => {
+                ref.dispose();
+            });
+        }
+        this._modelReferenceCollection.add(uri, ref);
+        return uri;
+    }
+    async $trySaveNotebook(uriComponents) {
+        const uri = URI.revive(uriComponents);
+        const ref = await this._notebookEditorModelResolverService.resolve(uri);
+        const saveResult = await ref.object.save();
+        ref.dispose();
+        return saveResult;
+    }
+};
+MainThreadNotebookDocuments = ( __decorate([( __param(1, INotebookEditorModelResolverService)), ( __param(2, IUriIdentityService))], MainThreadNotebookDocuments));
+
+export { MainThreadNotebookDocuments };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDocumentsAndEditors.d.ts

@@ -0,0 +1,29 @@
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+export declare class MainThreadNotebooksAndEditors {
+    private readonly _notebookService;
+    private readonly _notebookEditorService;
+    private readonly _editorService;
+    private readonly _editorGroupService;
+    private readonly _logService;
+    private readonly _proxy;
+    private readonly _disposables;
+    private readonly _editorListeners;
+    private _currentState?;
+    private readonly _mainThreadNotebooks;
+    private readonly _mainThreadEditors;
+    constructor(extHostContext: IExtHostContext, instantiationService: IInstantiationService, _notebookService: INotebookService, _notebookEditorService: INotebookEditorService, _editorService: IEditorService, _editorGroupService: IEditorGroupsService, _logService: ILogService);
+    dispose(): void;
+    private _handleEditorAdd;
+    private _handleEditorRemove;
+    private _updateState;
+    private _onDelta;
+    private static _isDeltaEmpty;
+    private static _asModelAddData;
+    private _asEditorAddData;
+}