@codingame/monaco-vscode-api 1.83.8 → 1.83.9

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

@@ -1,76 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { ILanguageStatusService } from '../../services/languageStatus/common/languageStatusService.js';
-import { DisposableStore, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-let MainThreadLanguages = class MainThreadLanguages {
-    constructor(_extHostContext, _languageService, _modelService, _resolverService, _languageStatusService) {
-        this._languageService = _languageService;
-        this._modelService = _modelService;
-        this._resolverService = _resolverService;
-        this._languageStatusService = _languageStatusService;
-        this._disposables = ( new DisposableStore());
-        this._status = ( new DisposableMap());
-        this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostLanguages));
-        this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
-        this._disposables.add(_languageService.onDidChange(_ => {
-            this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
-        }));
-    }
-    dispose() {
-        this._disposables.dispose();
-        this._status.dispose();
-    }
-    async $changeLanguage(resource, languageId) {
-        if (!this._languageService.isRegisteredLanguageId(languageId)) {
-            return Promise.reject(( new Error(`Unknown language id: ${languageId}`)));
-        }
-        const uri = URI.revive(resource);
-        const ref = await this._resolverService.createModelReference(uri);
-        try {
-            ref.object.textEditorModel.setLanguage(this._languageService.createById(languageId));
-        }
-        finally {
-            ref.dispose();
-        }
-    }
-    async $tokensAtPosition(resource, position) {
-        const uri = URI.revive(resource);
-        const model = this._modelService.getModel(uri);
-        if (!model) {
-            return undefined;
-        }
-        model.tokenization.tokenizeIfCheap(position.lineNumber);
-        const tokens = model.tokenization.getLineTokens(position.lineNumber);
-        const idx = tokens.findTokenIndexAtOffset(position.column - 1);
-        return {
-            type: tokens.getStandardTokenType(idx),
-            range: ( new Range(
-                position.lineNumber,
-                1 + tokens.getStartOffset(idx),
-                position.lineNumber,
-                1 + tokens.getEndOffset(idx)
-            ))
-        };
-    }
-    $setLanguageStatus(handle, status) {
-        this._status.get(handle)?.dispose();
-        this._status.set(handle, this._languageStatusService.addStatus(status));
-    }
-    $removeLanguageStatus(handle) {
-        this._status.get(handle)?.dispose();
-    }
-};
-MainThreadLanguages = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLanguages),
-    ( __param(1, ILanguageService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, ILanguageStatusService))
-], MainThreadLanguages);
-export { MainThreadLanguages };

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

@@ -1,33 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ILanguagePackService } from '../../../platform/languagePacks/common/languagePacks.js';
-let MainThreadLocalization = class MainThreadLocalization extends Disposable {
-    constructor(extHostContext, fileService, languagePackService) {
-        super();
-        this.fileService = fileService;
-        this.languagePackService = languagePackService;
-    }
-    async $fetchBuiltInBundleUri(id, language) {
-        try {
-            const uri = await this.languagePackService.getBuiltInExtensionTranslationsUri(id, language);
-            return uri;
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    async $fetchBundleContents(uriComponents) {
-        const contents = await this.fileService.readFile(URI.revive(uriComponents));
-        return ( contents.value.toString());
-    }
-};
-MainThreadLocalization = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLocalization),
-    ( __param(1, IFileService)),
-    ( __param(2, ILanguagePackService))
-], MainThreadLocalization);
-export { MainThreadLocalization };

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

@@ -1,76 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ILoggerService, parseLogLevel, ILogService, LogLevelToString, isLogLevel, log } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { MainContext, ExtHostContext } from '../common/extHost.protocol.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 { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-let MainThreadLoggerService = class MainThreadLoggerService {
-    constructor(extHostContext, loggerService) {
-        this.loggerService = loggerService;
-        this.disposables = ( new DisposableStore());
-        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLogLevelServiceShape));
-        this.disposables.add(loggerService.onDidChangeLogLevel(arg => {
-            if (isLogLevel(arg)) {
-                proxy.$setLogLevel(arg);
-            }
-            else {
-                proxy.$setLogLevel(arg[1], arg[0]);
-            }
-        }));
-    }
-    $log(file, messages) {
-        const logger = this.loggerService.getLogger(URI.revive(file));
-        if (!logger) {
-            throw new Error('Create the logger before logging');
-        }
-        for (const [level, message] of messages) {
-            log(logger, level, message);
-        }
-    }
-    async $createLogger(file, options) {
-        this.loggerService.createLogger(URI.revive(file), options);
-    }
-    async $registerLogger(logResource) {
-        this.loggerService.registerLogger({
-            ...logResource,
-            resource: URI.revive(logResource.resource)
-        });
-    }
-    async $deregisterLogger(resource) {
-        this.loggerService.deregisterLogger(URI.revive(resource));
-    }
-    async $setVisibility(resource, visible) {
-        this.loggerService.setVisibility(URI.revive(resource), visible);
-    }
-    $flush(file) {
-        const logger = this.loggerService.getLogger(URI.revive(file));
-        if (!logger) {
-            throw new Error('Create the logger before flushing');
-        }
-        logger.flush();
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-};
-MainThreadLoggerService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLogger),
-    ( __param(1, ILoggerService))
-], MainThreadLoggerService);
-CommandsRegistry.registerCommand('_extensionTests.setLogLevel', function (accessor, level) {
-    const loggerService = accessor.get(ILoggerService);
-    const environmentService = accessor.get(IEnvironmentService);
-    if (environmentService.isExtensionDevelopment && !!environmentService.extensionTestsLocationURI) {
-        const logLevel = parseLogLevel(level);
-        if (logLevel !== undefined) {
-            loggerService.setLogLevel(logLevel);
-        }
-    }
-});
-CommandsRegistry.registerCommand('_extensionTests.getLogLevel', function (accessor) {
-    const logService = accessor.get(ILogService);
-    return LogLevelToString(logService.getLevel());
-});
-export { MainThreadLoggerService };

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

@@ -1,91 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ManagedSocket, connectManagedSocket } from '../../../platform/remote/common/managedSocket.js';
-import { IRemoteSocketFactoryService } from '../../../platform/remote/common/remoteSocketFactoryService.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable {
-    constructor(extHostContext, _remoteSocketFactoryService) {
-        super();
-        this._remoteSocketFactoryService = _remoteSocketFactoryService;
-        this._registrations = ( new Map());
-        this._remoteSockets = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostManagedSockets));
-    }
-    async $registerSocketFactory(socketFactoryId) {
-        const that = this;
-        const socketFactory = new (class {
-            supports(connectTo) {
-                return (connectTo.id === socketFactoryId);
-            }
-            connect(connectTo, path, query, debugLabel) {
-                return ( new Promise((resolve, reject) => {
-                    if (connectTo.id !== socketFactoryId) {
-                        return reject(( new Error('Invalid connectTo')));
-                    }
-                    const factoryId = connectTo.id;
-                    that._proxy.$openRemoteSocket(factoryId).then(socketId => {
-                        const half = {
-                            onClose: ( new Emitter()),
-                            onData: ( new Emitter()),
-                            onEnd: ( new Emitter()),
-                        };
-                        that._remoteSockets.set(socketId, half);
-                        MainThreadManagedSocket.connect(socketId, that._proxy, path, query, debugLabel, half)
-                            .then(socket => {
-                            socket.onDidDispose(() => that._remoteSockets.delete(socketId));
-                            resolve(socket);
-                        }, err => {
-                            that._remoteSockets.delete(socketId);
-                            reject(err);
-                        });
-                    }).catch(reject);
-                }));
-            }
-        });
-        this._registrations.set(socketFactoryId, this._remoteSocketFactoryService.register(1 , socketFactory));
-    }
-    async $unregisterSocketFactory(socketFactoryId) {
-        this._registrations.get(socketFactoryId)?.dispose();
-    }
-    $onDidManagedSocketHaveData(socketId, data) {
-        this._remoteSockets.get(socketId)?.onData.fire(data);
-    }
-    $onDidManagedSocketClose(socketId, error) {
-        this._remoteSockets.get(socketId)?.onClose.fire({
-            type: 0 ,
-            error: error ? ( new Error(error)) : undefined,
-            hadError: !!error
-        });
-        this._remoteSockets.delete(socketId);
-    }
-    $onDidManagedSocketEnd(socketId) {
-        this._remoteSockets.get(socketId)?.onEnd.fire();
-    }
-};
-MainThreadManagedSockets = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadManagedSockets),
-    ( __param(1, IRemoteSocketFactoryService))
-], MainThreadManagedSockets);
-class MainThreadManagedSocket extends ManagedSocket {
-    static connect(socketId, proxy, path, query, debugLabel, half) {
-        const socket = ( new MainThreadManagedSocket(socketId, proxy, debugLabel, half));
-        return connectManagedSocket(socket, path, query, debugLabel, half);
-    }
-    constructor(socketId, proxy, debugLabel, half) {
-        super(debugLabel, half);
-        this.socketId = socketId;
-        this.proxy = proxy;
-    }
-    write(buffer) {
-        this.proxy.$remoteSocketWrite(this.socketId, buffer);
-    }
-    closeRemote() {
-        this.proxy.$remoteSocketEnd(this.socketId);
-    }
-    drain() {
-        return this.proxy.$remoteSocketDrain(this.socketId);
-    }
-}
-export { MainThreadManagedSocket, MainThreadManagedSockets };

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

@@ -1,116 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { toAction } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { IDialogService } from '../../../platform/dialogs/common/dialogs.js';
-let MainThreadMessageService = class MainThreadMessageService {
-    constructor(extHostContext, _notificationService, _dialogService) {
-        this._notificationService = _notificationService;
-        this._dialogService = _dialogService;
-    }
-    dispose() {
-    }
-    $showMessage(severity, message, options, commands) {
-        if (options.modal) {
-            return this._showModalMessage(severity, message, options.detail, commands, options.useCustom);
-        }
-        else {
-            return this._showMessage(severity, message, commands, options);
-        }
-    }
-    _showMessage(severity, message, commands, options) {
-        return ( new Promise(resolve => {
-            const primaryActions = ( commands.map(command => toAction({
-                id: `_extension_message_handle_${command.handle}`,
-                label: command.title,
-                enabled: true,
-                run: () => {
-                    resolve(command.handle);
-                    return Promise.resolve();
-                }
-            })));
-            let source;
-            if (options.source) {
-                source = {
-                    label: ( nls.localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadMessageService',
-                        'extensionSource',
-                        "{0} (Extension)",
-                        options.source.label
-                    )),
-                    id: options.source.identifier.value
-                };
-            }
-            if (!source) {
-                source = ( nls.localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadMessageService',
-                    'defaultSource',
-                    "Extension"
-                ));
-            }
-            const secondaryActions = [];
-            const messageHandle = this._notificationService.notify({
-                severity,
-                message,
-                actions: { primary: primaryActions, secondary: secondaryActions },
-                source
-            });
-            Event.once(messageHandle.onDidClose)(() => {
-                resolve(undefined);
-            });
-        }));
-    }
-    async _showModalMessage(severity, message, detail, commands, useCustom) {
-        const buttons = [];
-        let cancelButton = undefined;
-        for (const command of commands) {
-            const button = {
-                label: command.title,
-                run: () => command.handle
-            };
-            if (command.isCloseAffordance) {
-                cancelButton = button;
-            }
-            else {
-                buttons.push(button);
-            }
-        }
-        if (!cancelButton) {
-            if (buttons.length > 0) {
-                cancelButton = {
-                    label: ( nls.localizeWithPath('vs/workbench/api/browser/mainThreadMessageService', 'cancel', "Cancel")),
-                    run: () => undefined
-                };
-            }
-            else {
-                cancelButton = {
-                    label: ( nls.localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadMessageService',
-                        { key: 'ok', comment: ['&& denotes a mnemonic'] },
-                        "&&OK"
-                    )),
-                    run: () => undefined
-                };
-            }
-        }
-        const { result } = await this._dialogService.prompt({
-            type: severity,
-            message,
-            detail,
-            buttons,
-            cancelButton,
-            custom: useCustom
-        });
-        return result;
-    }
-};
-MainThreadMessageService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadMessageService),
-    ( __param(1, INotificationService)),
-    ( __param(2, IDialogService))
-], MainThreadMessageService);
-export { MainThreadMessageService };

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

@@ -1,156 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { NotebookDto } from './mainThreadNotebookDto.js';
-import { INotebookCellStatusBarService } from '../../contrib/notebook/common/notebookCellStatusBarService.js';
-import { INotebookService, SimpleNotebookProviderInfo } from '../../contrib/notebook/common/notebookService.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-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()));
-    }
-    $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);
-                return {
-                    ...stat,
-                    children: undefined,
-                    resource: uri
-                };
-            },
-        }));
-        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, ...args) => {
-    const [notebookType, dto] = args;
-    assertType(typeof notebookType === 'string', 'string');
-    assertType(typeof dto === 'object');
-    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;
-});
-export { MainThreadNotebooks };

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

@@ -1,121 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { BoundModelReferenceCollection } from './mainThreadDocuments.js';
-import { NotebookCellsChangeType } from '../../contrib/notebook/common/notebookCommon.js';
-import { INotebookEditorModelResolverService } from '../../contrib/notebook/common/notebookEditorModelResolverService.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { ExtHostContext } from '../common/extHost.protocol.js';
-import { NotebookDto } from './mainThreadNotebookDto.js';
-import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
-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) {
-        const ref = await this._notebookEditorModelResolverService.resolve({ untitledResource: undefined }, options.viewType);
-        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.resource;
-    }
-    async $tryOpenNotebook(uriComponents) {
-        const uri = URI.revive(uriComponents);
-        const ref = await this._notebookEditorModelResolverService.resolve(uri, undefined);
-        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 };