@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

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

@@ -0,0 +1,341 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableMap, DisposableStore, toDisposable, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.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 { NotebookDto } from './mainThreadNotebookDto.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+import { INotebookExecutionStateService, NotebookExecutionType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+
+class MainThreadKernel {
+    get preloadUris() {
+        return ( this.preloads.map(p => p.uri));
+    }
+    get preloadProvides() {
+        return ( this.preloads.map(p => p.provides)).flat();
+    }
+    constructor(data, _languageService) {
+        this._languageService = _languageService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.id = data.id;
+        this.viewType = data.notebookType;
+        this.extension = data.extensionId;
+        this.implementsInterrupt = data.supportsInterrupt ?? false;
+        this.label = data.label;
+        this.description = data.description;
+        this.detail = data.detail;
+        this.supportedLanguages = isNonEmptyArray(data.supportedLanguages) ? data.supportedLanguages : _languageService.getRegisteredLanguageIds();
+        this.implementsExecutionOrder = data.supportsExecutionOrder ?? false;
+        this.localResourceRoot = URI.revive(data.extensionLocation);
+        this.preloads = data.preloads?.map(u => ({ uri: URI.revive(u.uri), provides: u.provides })) ?? [];
+    }
+    update(data) {
+        const event = Object.create(null);
+        if (data.label !== undefined) {
+            this.label = data.label;
+            event.label = true;
+        }
+        if (data.description !== undefined) {
+            this.description = data.description;
+            event.description = true;
+        }
+        if (data.detail !== undefined) {
+            this.detail = data.detail;
+            event.detail = true;
+        }
+        if (data.supportedLanguages !== undefined) {
+            this.supportedLanguages = isNonEmptyArray(data.supportedLanguages) ? data.supportedLanguages : this._languageService.getRegisteredLanguageIds();
+            event.supportedLanguages = true;
+        }
+        if (data.supportsExecutionOrder !== undefined) {
+            this.implementsExecutionOrder = data.supportsExecutionOrder;
+            event.hasExecutionOrder = true;
+        }
+        if (data.supportsInterrupt !== undefined) {
+            this.implementsInterrupt = data.supportsInterrupt;
+            event.hasInterruptHandler = true;
+        }
+        this._onDidChange.fire(event);
+    }
+}
+class MainThreadKernelDetectionTask {
+    constructor(notebookType) {
+        this.notebookType = notebookType;
+    }
+}
+let MainThreadNotebookKernels = class MainThreadNotebookKernels {
+    constructor(extHostContext, _languageService, _notebookKernelService, _notebookExecutionStateService, _notebookService, notebookEditorService) {
+        this._languageService = _languageService;
+        this._notebookKernelService = _notebookKernelService;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this._notebookService = _notebookService;
+        this._editors = ( new DisposableMap());
+        this._disposables = ( new DisposableStore());
+        this._kernels = ( new Map());
+        this._kernelDetectionTasks = ( new Map());
+        this._kernelSourceActionProviders = ( new Map());
+        this._kernelSourceActionProvidersEventRegistrations = ( new Map());
+        this._executions = ( new Map());
+        this._notebookExecutions = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookKernels));
+        notebookEditorService.listNotebookEditors().forEach(this._onEditorAdd, this);
+        notebookEditorService.onDidAddNotebookEditor(this._onEditorAdd, this, this._disposables);
+        notebookEditorService.onDidRemoveNotebookEditor(this._onEditorRemove, this, this._disposables);
+        this._disposables.add(toDisposable(() => {
+            this._executions.forEach(e => {
+                e.complete({});
+            });
+            this._notebookExecutions.forEach(e => e.complete());
+        }));
+        this._disposables.add(this._notebookExecutionStateService.onDidChangeExecution(e => {
+            if (e.type === NotebookExecutionType.cell) {
+                this._proxy.$cellExecutionChanged(e.notebook, e.cellHandle, e.changed?.state);
+            }
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+        for (const [, registration] of ( this._kernels.values())) {
+            registration.dispose();
+        }
+        for (const [, registration] of ( this._kernelDetectionTasks.values())) {
+            registration.dispose();
+        }
+        for (const [, registration] of ( this._kernelSourceActionProviders.values())) {
+            registration.dispose();
+        }
+        this._editors.dispose();
+    }
+    _onEditorAdd(editor) {
+        const ipcListener = editor.onDidReceiveMessage(e => {
+            if (!editor.hasModel()) {
+                return;
+            }
+            const { selected } = this._notebookKernelService.getMatchingKernel(editor.textModel);
+            if (!selected) {
+                return;
+            }
+            for (const [handle, candidate] of this._kernels) {
+                if (candidate[0] === selected) {
+                    this._proxy.$acceptKernelMessageFromRenderer(handle, editor.getId(), e.message);
+                    break;
+                }
+            }
+        });
+        this._editors.set(editor, ipcListener);
+    }
+    _onEditorRemove(editor) {
+        this._editors.deleteAndDispose(editor);
+    }
+    async $postMessage(handle, editorId, message) {
+        const tuple = this._kernels.get(handle);
+        if (!tuple) {
+            throw new Error('kernel already disposed');
+        }
+        const [kernel] = tuple;
+        let didSend = false;
+        for (const [editor] of this._editors) {
+            if (!editor.hasModel()) {
+                continue;
+            }
+            if (this._notebookKernelService.getMatchingKernel(editor.textModel).selected !== kernel) {
+                continue;
+            }
+            if (editorId === undefined) {
+                editor.postMessage(message);
+                didSend = true;
+            }
+            else if (editor.getId() === editorId) {
+                editor.postMessage(message);
+                didSend = true;
+                break;
+            }
+        }
+        return didSend;
+    }
+    async $addKernel(handle, data) {
+        const that = this;
+        const kernel = new (class extends MainThreadKernel {
+            async executeNotebookCellsRequest(uri, handles) {
+                await that._proxy.$executeCells(handle, uri, handles);
+            }
+            async cancelNotebookCellExecution(uri, handles) {
+                await that._proxy.$cancelCells(handle, uri, handles);
+            }
+        })(data, this._languageService);
+        const listener = this._notebookKernelService.onDidChangeSelectedNotebooks(e => {
+            if (e.oldKernel === kernel.id) {
+                this._proxy.$acceptNotebookAssociation(handle, e.notebook, false);
+            }
+            else if (e.newKernel === kernel.id) {
+                this._proxy.$acceptNotebookAssociation(handle, e.notebook, true);
+            }
+        });
+        const registration = this._notebookKernelService.registerKernel(kernel);
+        this._kernels.set(handle, [kernel, combinedDisposable(listener, registration)]);
+    }
+    $updateKernel(handle, data) {
+        const tuple = this._kernels.get(handle);
+        if (tuple) {
+            tuple[0].update(data);
+        }
+    }
+    $removeKernel(handle) {
+        const tuple = this._kernels.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this._kernels.delete(handle);
+        }
+    }
+    $updateNotebookPriority(handle, notebook, value) {
+        const tuple = this._kernels.get(handle);
+        if (tuple) {
+            this._notebookKernelService.updateKernelNotebookAffinity(tuple[0], URI.revive(notebook), value);
+        }
+    }
+    $createExecution(handle, controllerId, rawUri, cellHandle) {
+        const uri = URI.revive(rawUri);
+        const notebook = this._notebookService.getNotebookTextModel(uri);
+        if (!notebook) {
+            throw new Error(`Notebook not found: ${uri.toString()}`);
+        }
+        const kernel = this._notebookKernelService.getMatchingKernel(notebook);
+        if (!kernel.selected || kernel.selected.id !== controllerId) {
+            throw new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`);
+        }
+        const execution = this._notebookExecutionStateService.createCellExecution(uri, cellHandle);
+        execution.confirm();
+        this._executions.set(handle, execution);
+    }
+    $updateExecution(handle, data) {
+        const updates = data.value;
+        try {
+            const execution = this._executions.get(handle);
+            execution?.update(( updates.map(NotebookDto.fromCellExecuteUpdateDto)));
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+    }
+    $completeExecution(handle, data) {
+        try {
+            const execution = this._executions.get(handle);
+            execution?.complete(NotebookDto.fromCellExecuteCompleteDto(data.value));
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+        finally {
+            this._executions.delete(handle);
+        }
+    }
+    $createNotebookExecution(handle, controllerId, rawUri) {
+        const uri = URI.revive(rawUri);
+        const notebook = this._notebookService.getNotebookTextModel(uri);
+        if (!notebook) {
+            throw new Error(`Notebook not found: ${uri.toString()}`);
+        }
+        const kernel = this._notebookKernelService.getMatchingKernel(notebook);
+        if (!kernel.selected || kernel.selected.id !== controllerId) {
+            throw new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`);
+        }
+        const execution = this._notebookExecutionStateService.createExecution(uri);
+        execution.confirm();
+        this._notebookExecutions.set(handle, execution);
+    }
+    $beginNotebookExecution(handle) {
+        try {
+            const execution = this._notebookExecutions.get(handle);
+            execution?.begin();
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+    }
+    $completeNotebookExecution(handle) {
+        try {
+            const execution = this._notebookExecutions.get(handle);
+            execution?.complete();
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+        finally {
+            this._notebookExecutions.delete(handle);
+        }
+    }
+    async $addKernelDetectionTask(handle, notebookType) {
+        const kernelDetectionTask = ( new MainThreadKernelDetectionTask(notebookType));
+        const registration = this._notebookKernelService.registerNotebookKernelDetectionTask(kernelDetectionTask);
+        this._kernelDetectionTasks.set(handle, [kernelDetectionTask, registration]);
+    }
+    $removeKernelDetectionTask(handle) {
+        const tuple = this._kernelDetectionTasks.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this._kernelDetectionTasks.delete(handle);
+        }
+    }
+    async $addKernelSourceActionProvider(handle, eventHandle, notebookType) {
+        const kernelSourceActionProvider = {
+            viewType: notebookType,
+            provideKernelSourceActions: async () => {
+                const actions = await this._proxy.$provideKernelSourceActions(handle, CancellationToken.None);
+                return ( actions.map(action => {
+                    let documentation = action.documentation;
+                    if (action.documentation && typeof action.documentation !== 'string') {
+                        documentation = URI.revive(action.documentation);
+                    }
+                    return {
+                        label: action.label,
+                        command: action.command,
+                        description: action.description,
+                        detail: action.detail,
+                        documentation,
+                    };
+                }));
+            }
+        };
+        if (typeof eventHandle === 'number') {
+            const emitter = ( new Emitter());
+            this._kernelSourceActionProvidersEventRegistrations.set(eventHandle, emitter);
+            kernelSourceActionProvider.onDidChangeSourceActions = emitter.event;
+        }
+        const registration = this._notebookKernelService.registerKernelSourceActionProvider(notebookType, kernelSourceActionProvider);
+        this._kernelSourceActionProviders.set(handle, [kernelSourceActionProvider, registration]);
+    }
+    $removeKernelSourceActionProvider(handle, eventHandle) {
+        const tuple = this._kernelSourceActionProviders.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this._kernelSourceActionProviders.delete(handle);
+        }
+        if (typeof eventHandle === 'number') {
+            this._kernelSourceActionProvidersEventRegistrations.delete(eventHandle);
+        }
+    }
+    $emitNotebookKernelSourceActionsChangeEvent(eventHandle) {
+        const emitter = this._kernelSourceActionProvidersEventRegistrations.get(eventHandle);
+        if (emitter instanceof Emitter) {
+            emitter.fire(undefined);
+        }
+    }
+};
+MainThreadNotebookKernels = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadNotebookKernels),
+    ( __param(1, ILanguageService)),
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, INotebookExecutionStateService)),
+    ( __param(4, INotebookService)),
+    ( __param(5, INotebookEditorService))
+], MainThreadNotebookKernels);
+
+export { MainThreadNotebookKernels };

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

@@ -0,0 +1,25 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { INotebookRendererMessagingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService';
+
+let MainThreadNotebookRenderers = class MainThreadNotebookRenderers extends Disposable {
+    constructor(extHostContext, messaging) {
+        super();
+        this.messaging = messaging;
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookRenderers));
+        this._register(messaging.onShouldPostMessage(e => {
+            this.proxy.$postRendererMessage(e.editorId, e.rendererId, e.message);
+        }));
+    }
+    $postMessage(editorId, rendererId, message) {
+        return this.messaging.receiveMessage(editorId, rendererId, message);
+    }
+};
+MainThreadNotebookRenderers = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadNotebookRenderers),
+    ( __param(1, INotebookRendererMessagingService))
+], MainThreadNotebookRenderers);
+
+export { MainThreadNotebookRenderers };

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

@@ -0,0 +1,48 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { raceCancellationError } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { NotebookFileWorkingCopyModel } from '../../contrib/notebook/common/notebookEditorModel.js';
+
+class ExtHostNotebookDocumentSaveParticipant {
+    constructor(extHostContext) {
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocumentSaveParticipant));
+    }
+    async participate(workingCopy, env, _progress, token) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return undefined;
+        }
+        let _warningTimeout;
+        const p = ( new Promise((resolve, reject) => {
+            _warningTimeout = setTimeout(() => reject(( new Error(( localizeWithPath(
+                'vs/workbench/api/browser/mainThreadNotebookSaveParticipant',
+                'timeout.onWillSave',
+                "Aborted onWillSaveNotebookDocument-event after 1750ms"
+            ))))), 1750);
+            this._proxy.$participateInSave(workingCopy.resource, env.reason, token).then(_ => {
+                clearTimeout(_warningTimeout);
+                return undefined;
+            }).then(resolve, reject);
+        }));
+        return raceCancellationError(p, token);
+    }
+}
+let SaveParticipant = class SaveParticipant {
+    constructor(extHostContext, instantiationService, workingCopyFileService) {
+        this.workingCopyFileService = workingCopyFileService;
+        this._saveParticipantDisposable = this.workingCopyFileService.addSaveParticipant(instantiationService.createInstance(ExtHostNotebookDocumentSaveParticipant, extHostContext));
+    }
+    dispose() {
+        this._saveParticipantDisposable.dispose();
+    }
+};
+SaveParticipant = __decorate([
+    extHostCustomer,
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IWorkingCopyFileService))
+], SaveParticipant);
+
+export { SaveParticipant };

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

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { OUTPUT_VIEW_ID, Extensions, OutputChannelUpdateMode, IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+
+var MainThreadOutputService_1;
+let MainThreadOutputService = class MainThreadOutputService extends Disposable {
+    static { MainThreadOutputService_1 = this; }
+    static { this._extensionIdPool = ( new Map()); }
+    constructor(extHostContext, outputService, viewsService) {
+        super();
+        this._outputService = outputService;
+        this._viewsService = viewsService;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostOutputService));
+        const setVisibleChannel = () => {
+            const visibleChannel = this._viewsService.isViewVisible(OUTPUT_VIEW_ID) ? this._outputService.getActiveChannel() : undefined;
+            this._proxy.$setVisibleChannel(visibleChannel ? visibleChannel.id : null);
+        };
+        this._register(Event.any(this._outputService.onActiveOutputChannel, Event.filter(this._viewsService.onDidChangeViewVisibility, ({ id }) => id === OUTPUT_VIEW_ID))(() => setVisibleChannel()));
+        setVisibleChannel();
+    }
+    async $register(label, file, languageId, extensionId) {
+        const idCounter = (MainThreadOutputService_1._extensionIdPool.get(extensionId) || 0) + 1;
+        MainThreadOutputService_1._extensionIdPool.set(extensionId, idCounter);
+        const id = `extension-output-${extensionId}-#${idCounter}-${label}`;
+        const resource = URI.revive(file);
+        ( Registry.as(Extensions.OutputChannels)).registerChannel({ id, label, file: resource, log: false, languageId, extensionId });
+        this._register(toDisposable(() => this.$dispose(id)));
+        return id;
+    }
+    async $update(channelId, mode, till) {
+        const channel = this._getChannel(channelId);
+        if (channel) {
+            if (mode === OutputChannelUpdateMode.Append) {
+                channel.update(mode);
+            }
+            else if (isNumber(till)) {
+                channel.update(mode, till);
+            }
+        }
+    }
+    async $reveal(channelId, preserveFocus) {
+        const channel = this._getChannel(channelId);
+        if (channel) {
+            this._outputService.showChannel(channel.id, preserveFocus);
+        }
+    }
+    async $close(channelId) {
+        if (this._viewsService.isViewVisible(OUTPUT_VIEW_ID)) {
+            const activeChannel = this._outputService.getActiveChannel();
+            if (activeChannel && channelId === activeChannel.id) {
+                this._viewsService.closeView(OUTPUT_VIEW_ID);
+            }
+        }
+    }
+    async $dispose(channelId) {
+        const channel = this._getChannel(channelId);
+        channel?.dispose();
+    }
+    _getChannel(channelId) {
+        return this._outputService.getChannel(channelId);
+    }
+};
+MainThreadOutputService = MainThreadOutputService_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadOutputService),
+    ( __param(1, IOutputService)),
+    ( __param(2, IViewsService))
+], MainThreadOutputService);
+
+export { MainThreadOutputService };

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

@@ -0,0 +1,38 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IUserDataProfileImportExportService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+
+let MainThreadProfileContentHandlers = class MainThreadProfileContentHandlers extends Disposable {
+    constructor(context, userDataProfileImportExportService) {
+        super();
+        this.userDataProfileImportExportService = userDataProfileImportExportService;
+        this.registeredHandlers = this._register(( new DisposableMap()));
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostProfileContentHandlers));
+    }
+    async $registerProfileContentHandler(id, name, description, extensionId) {
+        this.registeredHandlers.set(id, this.userDataProfileImportExportService.registerProfileContentHandler(id, {
+            name,
+            description,
+            extensionId,
+            saveProfile: async (name, content, token) => {
+                const result = await this.proxy.$saveProfile(id, name, content, token);
+                return result ? revive(result) : null;
+            },
+            readProfile: async (uri, token) => {
+                return this.proxy.$readProfile(id, uri, token);
+            },
+        }));
+    }
+    async $unregisterProfileContentHandler(id) {
+        this.registeredHandlers.deleteAndDispose(id);
+    }
+};
+MainThreadProfileContentHandlers = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadProfileContentHandlers),
+    ( __param(1, IUserDataProfileImportExportService))
+], MainThreadProfileContentHandlers);
+
+export { MainThreadProfileContentHandlers };

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

@@ -0,0 +1,68 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+class ManageExtensionAction extends Action {
+    constructor(extensionId, label, commandService) {
+        super(extensionId, label, undefined, true, () => {
+            return commandService.executeCommand('_extensions.manage', extensionId);
+        });
+    }
+}
+let MainThreadProgress = class MainThreadProgress {
+    constructor(extHostContext, progressService, _commandService) {
+        this._commandService = _commandService;
+        this._progress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostProgress));
+        this._progressService = progressService;
+    }
+    dispose() {
+        this._progress.forEach(handle => handle.resolve());
+        this._progress.clear();
+    }
+    async $startProgress(handle, options, extensionId) {
+        const task = this._createTask(handle);
+        if (options.location === 15  && extensionId) {
+            const notificationOptions = {
+                ...options,
+                location: 15 ,
+                secondaryActions: [( new ManageExtensionAction(extensionId, ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadProgress',
+                    'manageExtension',
+                    "Manage Extension"
+                )), this._commandService))]
+            };
+            options = notificationOptions;
+        }
+        this._progressService.withProgress(options, task, () => this._proxy.$acceptProgressCanceled(handle));
+    }
+    $progressReport(handle, message) {
+        const entry = this._progress.get(handle);
+        entry?.progress.report(message);
+    }
+    $progressEnd(handle) {
+        const entry = this._progress.get(handle);
+        if (entry) {
+            entry.resolve();
+            this._progress.delete(handle);
+        }
+    }
+    _createTask(handle) {
+        return (progress) => {
+            return ( new Promise(resolve => {
+                this._progress.set(handle, { resolve, progress });
+            }));
+        };
+    }
+};
+MainThreadProgress = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadProgress),
+    ( __param(1, IProgressService)),
+    ( __param(2, ICommandService))
+], MainThreadProgress);
+
+export { MainThreadProgress };

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

@@ -0,0 +1,49 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadQuickDiff = class MainThreadQuickDiff {
+    constructor(extHostContext, quickDiffService) {
+        this.quickDiffService = quickDiffService;
+        this.providers = ( new Map());
+        this.providerDisposables = ( new Map());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostQuickDiff));
+    }
+    async $registerQuickDiffProvider(handle, selector, label, rootUri) {
+        const provider = {
+            label,
+            rootUri: URI.revive(rootUri),
+            selector,
+            isSCM: false,
+            getOriginalResource: async (uri) => {
+                return URI.revive(await this.proxy.$provideOriginalResource(handle, uri, ( new CancellationTokenSource()).token));
+            }
+        };
+        this.providers.set(handle, provider);
+        const disposable = this.quickDiffService.addQuickDiffProvider(provider);
+        this.providerDisposables.set(handle, disposable);
+    }
+    async $unregisterQuickDiffProvider(handle) {
+        if (( this.providers.has(handle))) {
+            this.providers.delete(handle);
+        }
+        if (( this.providerDisposables.has(handle))) {
+            this.providerDisposables.delete(handle);
+        }
+    }
+    dispose() {
+        this.providers.clear();
+        dispose(( this.providerDisposables.values()));
+        this.providerDisposables.clear();
+    }
+};
+MainThreadQuickDiff = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadQuickDiff),
+    ( __param(1, IQuickDiffService))
+], MainThreadQuickDiff);
+
+export { MainThreadQuickDiff };