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

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

@@ -1,22 +0,0 @@
-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 "../../services/extensions/common/extHostCustomers.js";
-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

@@ -1,210 +0,0 @@
-
-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 './mainThreadNotebookDto.js';
-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 '../../services/extensions/common/extHostCustomers.js';
-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

@@ -1,24 +0,0 @@
-import { URI, UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
-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 "../../services/extensions/common/extHostCustomers.js";
-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

@@ -1,138 +0,0 @@
-
-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 './mainThreadDocuments.js';
-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 './mainThreadNotebookDto.js';
-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

@@ -1,29 +0,0 @@
-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 "../../services/extensions/common/extHostCustomers.js";
-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;
-}

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

@@ -1,194 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { diffSets, diffMaps } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
-import { DisposableStore, DisposableMap, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-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 { MainThreadNotebookDocuments } from './mainThreadNotebookDocuments.js';
-import { NotebookDto } from './mainThreadNotebookDto.js';
-import { MainThreadNotebookEditors } from './mainThreadNotebookEditors.js';
-import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { editorGroupToColumn } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupColumn';
-import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-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';
-import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { SerializableObjectWithBuffers } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
-
-var MainThreadNotebooksAndEditors_1;
-class NotebookAndEditorState {
-    static delta(before, after) {
-        if (!before) {
-            return {
-                addedDocuments: [...after.documents],
-                removedDocuments: [],
-                addedEditors: [...( after.textEditors.values())],
-                removedEditors: [],
-                visibleEditors: ( [...after.visibleEditors].map(editor => editor[0]))
-            };
-        }
-        const documentDelta = diffSets(before.documents, after.documents);
-        const editorDelta = diffMaps(before.textEditors, after.textEditors);
-        const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
-        const visibleEditorDelta = diffMaps(before.visibleEditors, after.visibleEditors);
-        return {
-            addedDocuments: documentDelta.added,
-            removedDocuments: ( documentDelta.removed.map(e => e.uri)),
-            addedEditors: editorDelta.added,
-            removedEditors: ( editorDelta.removed.map(removed => removed.getId())),
-            newActiveEditor: newActiveEditor,
-            visibleEditors: visibleEditorDelta.added.length === 0 && visibleEditorDelta.removed.length === 0 ? undefined : ( [...after.visibleEditors].map(editor => editor[0]))
-        };
-    }
-    constructor(documents, textEditors, activeEditor, visibleEditors) {
-        this.documents = documents;
-        this.textEditors = textEditors;
-        this.activeEditor = activeEditor;
-        this.visibleEditors = visibleEditors;
-    }
-}
-let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class MainThreadNotebooksAndEditors {
-    constructor(
-        extHostContext,
-        instantiationService,
-        _notebookService,
-        _notebookEditorService,
-        _editorService,
-        _editorGroupService,
-        _logService
-    ) {
-        this._notebookService = _notebookService;
-        this._notebookEditorService = _notebookEditorService;
-        this._editorService = _editorService;
-        this._editorGroupService = _editorGroupService;
-        this._logService = _logService;
-        this._disposables = ( new DisposableStore());
-        this._editorListeners = ( new DisposableMap());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebook));
-        this._mainThreadNotebooks = instantiationService.createInstance(MainThreadNotebookDocuments, extHostContext);
-        this._mainThreadEditors = instantiationService.createInstance(MainThreadNotebookEditors, extHostContext);
-        extHostContext.set(MainContext.MainThreadNotebookDocuments, this._mainThreadNotebooks);
-        extHostContext.set(MainContext.MainThreadNotebookEditors, this._mainThreadEditors);
-        this._notebookService.onWillAddNotebookDocument(() => this._updateState(), this, this._disposables);
-        this._notebookService.onDidRemoveNotebookDocument(() => this._updateState(), this, this._disposables);
-        this._editorService.onDidActiveEditorChange(() => this._updateState(), this, this._disposables);
-        this._editorService.onDidVisibleEditorsChange(() => this._updateState(), this, this._disposables);
-        this._notebookEditorService.onDidAddNotebookEditor(this._handleEditorAdd, this, this._disposables);
-        this._notebookEditorService.onDidRemoveNotebookEditor(this._handleEditorRemove, this, this._disposables);
-        this._updateState();
-    }
-    dispose() {
-        this._mainThreadNotebooks.dispose();
-        this._mainThreadEditors.dispose();
-        this._disposables.dispose();
-        this._editorListeners.dispose();
-    }
-    _handleEditorAdd(editor) {
-        this._editorListeners.set(editor.getId(), combinedDisposable(
-            editor.onDidChangeModel(() => this._updateState()),
-            editor.onDidFocusWidget(() => this._updateState(editor))
-        ));
-        this._updateState();
-    }
-    _handleEditorRemove(editor) {
-        this._editorListeners.deleteAndDispose(editor.getId());
-        this._updateState();
-    }
-    _updateState(focusedEditor) {
-        const editors = ( new Map());
-        const visibleEditorsMap = ( new Map());
-        for (const editor of this._notebookEditorService.listNotebookEditors()) {
-            if (editor.hasModel()) {
-                editors.set(editor.getId(), editor);
-            }
-        }
-        const activeNotebookEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        let activeEditor = null;
-        if (activeNotebookEditor) {
-            activeEditor = activeNotebookEditor.getId();
-        } else if (focusedEditor?.textModel) {
-            activeEditor = focusedEditor.getId();
-        }
-        if (activeEditor && !( editors.has(activeEditor))) {
-            this._logService.trace(
-                "MainThreadNotebooksAndEditors#_updateState: active editor is not in editors list",
-                activeEditor,
-                ( editors.keys())
-            );
-            activeEditor = null;
-        }
-        for (const editorPane of this._editorService.visibleEditorPanes) {
-            const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
-            if (notebookEditor?.hasModel() && ( editors.has(notebookEditor.getId()))) {
-                visibleEditorsMap.set(notebookEditor.getId(), notebookEditor);
-            }
-        }
-        const newState = ( new NotebookAndEditorState(( new Set(this._notebookService.listNotebookDocuments())), editors, activeEditor, visibleEditorsMap));
-        this._onDelta(NotebookAndEditorState.delta(this._currentState, newState));
-        this._currentState = newState;
-    }
-    _onDelta(delta) {
-        if (MainThreadNotebooksAndEditors_1._isDeltaEmpty(delta)) {
-            return;
-        }
-        const dto = {
-            removedDocuments: delta.removedDocuments,
-            removedEditors: delta.removedEditors,
-            newActiveEditor: delta.newActiveEditor,
-            visibleEditors: delta.visibleEditors,
-            addedDocuments: ( delta.addedDocuments.map(MainThreadNotebooksAndEditors_1._asModelAddData)),
-            addedEditors: ( delta.addedEditors.map(this._asEditorAddData, this))
-        };
-        this._proxy.$acceptDocumentAndEditorsDelta(( new SerializableObjectWithBuffers(dto)));
-        this._mainThreadEditors.handleEditorsRemoved(delta.removedEditors);
-        this._mainThreadNotebooks.handleNotebooksRemoved(delta.removedDocuments);
-        this._mainThreadNotebooks.handleNotebooksAdded(delta.addedDocuments);
-        this._mainThreadEditors.handleEditorsAdded(delta.addedEditors);
-    }
-    static _isDeltaEmpty(delta) {
-        if (delta.addedDocuments !== undefined && delta.addedDocuments.length > 0) {
-            return false;
-        }
-        if (delta.removedDocuments !== undefined && delta.removedDocuments.length > 0) {
-            return false;
-        }
-        if (delta.addedEditors !== undefined && delta.addedEditors.length > 0) {
-            return false;
-        }
-        if (delta.removedEditors !== undefined && delta.removedEditors.length > 0) {
-            return false;
-        }
-        if (delta.visibleEditors !== undefined && delta.visibleEditors.length > 0) {
-            return false;
-        }
-        if (delta.newActiveEditor !== undefined) {
-            return false;
-        }
-        return true;
-    }
-    static _asModelAddData(e) {
-        return {
-            viewType: e.viewType,
-            uri: e.uri,
-            metadata: e.metadata,
-            versionId: e.versionId,
-            cells: ( e.cells.map(NotebookDto.toNotebookCellDto))
-        };
-    }
-    _asEditorAddData(add) {
-        const pane = this._editorService.visibleEditorPanes.find(pane => getNotebookEditorFromEditorPane(pane) === add);
-        return {
-            id: add.getId(),
-            documentUri: add.textModel.uri,
-            selections: add.getSelections(),
-            visibleRanges: add.visibleRanges,
-            viewColumn: pane && editorGroupToColumn(this._editorGroupService, pane.group),
-            viewType: add.getViewModel().viewType
-        };
-    }
-};
-MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = __decorate([extHostCustomer, ( __param(1, IInstantiationService)), ( __param(2, INotebookService)), ( __param(3, INotebookEditorService)), ( __param(4, IEditorService)), ( __param(5, IEditorGroupsService)), ( __param(6, ILogService))], MainThreadNotebooksAndEditors);
-
-export { MainThreadNotebooksAndEditors };

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

@@ -1,17 +0,0 @@
-import * as extHostProtocol from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
-import * as notebookCommon from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
-import { ICellExecuteUpdate, ICellExecutionComplete } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService";
-export declare namespace NotebookDto {
-    function toNotebookOutputItemDto(item: notebookCommon.IOutputItemDto): extHostProtocol.NotebookOutputItemDto;
-    function toNotebookOutputDto(output: notebookCommon.IOutputDto): extHostProtocol.NotebookOutputDto;
-    function toNotebookCellDataDto(cell: notebookCommon.ICellDto2): extHostProtocol.NotebookCellDataDto;
-    function toNotebookDataDto(data: notebookCommon.NotebookData): extHostProtocol.NotebookDataDto;
-    function fromNotebookOutputItemDto(item: extHostProtocol.NotebookOutputItemDto): notebookCommon.IOutputItemDto;
-    function fromNotebookOutputDto(output: extHostProtocol.NotebookOutputDto): notebookCommon.IOutputDto;
-    function fromNotebookCellDataDto(cell: extHostProtocol.NotebookCellDataDto): notebookCommon.ICellDto2;
-    function fromNotebookDataDto(data: extHostProtocol.NotebookDataDto): notebookCommon.NotebookData;
-    function toNotebookCellDto(cell: notebookCommon.ICell): extHostProtocol.NotebookCellDto;
-    function fromCellExecuteUpdateDto(data: extHostProtocol.ICellExecuteUpdateDto): ICellExecuteUpdate;
-    function fromCellExecuteCompleteDto(data: extHostProtocol.ICellExecutionCompleteDto): ICellExecutionComplete;
-    function fromCellEditOperationDto(edit: extHostProtocol.ICellEditOperationDto): notebookCommon.ICellEditOperation;
-}