@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,433 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, toDisposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { URI } from '../../../base/common/uri.js';
+import { IDebugVisualization, IDebugService } from '../../contrib/debug/common/debug.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import Severity$1 from '../../../base/common/severity.js';
+import { AbstractDebugAdapter } from '../../contrib/debug/common/abstractDebugAdapter.js';
+import { isSessionAttach, convertToVSCPaths, convertToDAPaths } from '../../contrib/debug/common/debugUtils.js';
+import { ErrorNoTelemetry } from '../../../base/common/errors.js';
+import { IDebugVisualizerService } from '../../contrib/debug/common/debugVisualizers.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
+import { Event } from '../../../base/common/event.js';
+let MainThreadDebugService = class MainThreadDebugService {
+    constructor(extHostContext, debugService, visualizerService) {
+        this.debugService = debugService;
+        this.visualizerService = visualizerService;
+        this._toDispose = ( new DisposableStore());
+        this._debugAdaptersHandleCounter = 1;
+        this._visualizerHandles = ( new Map());
+        this._visualizerTreeHandles = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDebugService));
+        const sessionListeners = ( new DisposableMap());
+        this._toDispose.add(sessionListeners);
+        this._toDispose.add(debugService.onDidNewSession(session => {
+            this._proxy.$acceptDebugSessionStarted(this.getSessionDto(session));
+            const store = sessionListeners.get(session);
+            store.add(session.onDidChangeName(name => {
+                this._proxy.$acceptDebugSessionNameChanged(this.getSessionDto(session), name);
+            }));
+        }));
+        this._toDispose.add(debugService.onWillNewSession(session => {
+            let store = sessionListeners.get(session);
+            if (!store) {
+                store = ( new DisposableStore());
+                sessionListeners.set(session, store);
+            }
+            store.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
+        }));
+        this._toDispose.add(debugService.onDidEndSession(({ session, restart }) => {
+            this._proxy.$acceptDebugSessionTerminated(this.getSessionDto(session));
+            this._extHostKnownSessions.delete(session.getId());
+            if (!restart) {
+                sessionListeners.deleteAndDispose(session);
+            }
+            for (const [handle, value] of this._debugAdapters) {
+                if (value.session === session) {
+                    this._debugAdapters.delete(handle);
+                }
+            }
+        }));
+        this._toDispose.add(debugService.getViewModel().onDidFocusSession(session => {
+            this._proxy.$acceptDebugSessionActiveChanged(this.getSessionDto(session));
+        }));
+        this._toDispose.add(toDisposable(() => {
+            for (const [handle, da] of this._debugAdapters) {
+                da.fireError(handle, ( new Error('Extension host shut down')));
+            }
+        }));
+        this._debugAdapters = ( new Map());
+        this._debugConfigurationProviders = ( new Map());
+        this._debugAdapterDescriptorFactories = ( new Map());
+        this._extHostKnownSessions = ( new Set());
+        const viewModel = this.debugService.getViewModel();
+        this._toDispose.add(Event.any(viewModel.onDidFocusStackFrame, viewModel.onDidFocusThread)(() => {
+            const stackFrame = viewModel.focusedStackFrame;
+            const thread = viewModel.focusedThread;
+            if (stackFrame) {
+                this._proxy.$acceptStackFrameFocus({
+                    kind: 'stackFrame',
+                    threadId: stackFrame.thread.threadId,
+                    frameId: stackFrame.frameId,
+                    sessionId: stackFrame.thread.session.getId(),
+                });
+            }
+            else if (thread) {
+                this._proxy.$acceptStackFrameFocus({
+                    kind: 'thread',
+                    threadId: thread.threadId,
+                    sessionId: thread.session.getId(),
+                });
+            }
+            else {
+                this._proxy.$acceptStackFrameFocus(undefined);
+            }
+        }));
+        this.sendBreakpointsAndListen();
+    }
+    $registerDebugVisualizerTree(treeId, canEdit) {
+        this.visualizerService.registerTree(treeId, {
+            disposeItem: id => this._proxy.$disposeVisualizedTree(id),
+            getChildren: e => this._proxy.$getVisualizerTreeItemChildren(treeId, e),
+            getTreeItem: e => this._proxy.$getVisualizerTreeItem(treeId, e),
+            editItem: canEdit ? ((e, v) => this._proxy.$editVisualizerTreeItem(e, v)) : undefined
+        });
+    }
+    $unregisterDebugVisualizerTree(treeId) {
+        this._visualizerTreeHandles.get(treeId)?.dispose();
+        this._visualizerTreeHandles.delete(treeId);
+    }
+    $registerDebugVisualizer(extensionId, id) {
+        const handle = this.visualizerService.register({
+            extensionId: ( new ExtensionIdentifier(extensionId)),
+            id,
+            disposeDebugVisualizers: ids => this._proxy.$disposeDebugVisualizers(ids),
+            executeDebugVisualizerCommand: id => this._proxy.$executeDebugVisualizerCommand(id),
+            provideDebugVisualizers: (context, token) => this._proxy.$provideDebugVisualizers(extensionId, id, context, token).then(r => ( r.map(IDebugVisualization.deserialize))),
+            resolveDebugVisualizer: (viz, token) => this._proxy.$resolveDebugVisualizer(viz.id, token),
+        });
+        this._visualizerHandles.set(`${extensionId}/${id}`, handle);
+    }
+    $unregisterDebugVisualizer(extensionId, id) {
+        const key = `${extensionId}/${id}`;
+        this._visualizerHandles.get(key)?.dispose();
+        this._visualizerHandles.delete(key);
+    }
+    sendBreakpointsAndListen() {
+        this._toDispose.add(this.debugService.getModel().onDidChangeBreakpoints(e => {
+            if (e && !e.sessionOnly) {
+                const delta = {};
+                if (e.added) {
+                    delta.added = this.convertToDto(e.added);
+                }
+                if (e.removed) {
+                    delta.removed = ( e.removed.map(x => x.getId()));
+                }
+                if (e.changed) {
+                    delta.changed = this.convertToDto(e.changed);
+                }
+                if (delta.added || delta.removed || delta.changed) {
+                    this._proxy.$acceptBreakpointsDelta(delta);
+                }
+            }
+        }));
+        const bps = this.debugService.getModel().getBreakpoints();
+        const fbps = this.debugService.getModel().getFunctionBreakpoints();
+        const dbps = this.debugService.getModel().getDataBreakpoints();
+        if (bps.length > 0 || fbps.length > 0) {
+            this._proxy.$acceptBreakpointsDelta({
+                added: this.convertToDto(bps).concat(this.convertToDto(fbps)).concat(this.convertToDto(dbps))
+            });
+        }
+    }
+    dispose() {
+        this._toDispose.dispose();
+    }
+    createDebugAdapter(session) {
+        const handle = this._debugAdaptersHandleCounter++;
+        const da = ( new ExtensionHostDebugAdapter(this, handle, this._proxy, session));
+        this._debugAdapters.set(handle, da);
+        return da;
+    }
+    substituteVariables(folder, config) {
+        return Promise.resolve(this._proxy.$substituteVariables(folder ? folder.uri : undefined, config));
+    }
+    runInTerminal(args, sessionId) {
+        return this._proxy.$runInTerminal(args, sessionId);
+    }
+    $registerDebugTypes(debugTypes) {
+        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterFactory(debugTypes, this));
+    }
+    $registerBreakpoints(DTOs) {
+        for (const dto of DTOs) {
+            if (dto.type === 'sourceMulti') {
+                const rawbps = ( dto.lines.map(l => ({
+                    id: l.id,
+                    enabled: l.enabled,
+                    lineNumber: l.line + 1,
+                    column: l.character > 0 ? l.character + 1 : undefined,
+                    condition: l.condition,
+                    hitCondition: l.hitCondition,
+                    logMessage: l.logMessage,
+                    mode: l.mode,
+                })));
+                this.debugService.addBreakpoints(URI.revive(dto.uri), rawbps);
+            }
+            else if (dto.type === 'function') {
+                this.debugService.addFunctionBreakpoint(dto.functionName, dto.id, dto.mode);
+            }
+            else if (dto.type === 'data') {
+                this.debugService.addDataBreakpoint({
+                    description: dto.label,
+                    src: { type: 0 , dataId: dto.dataId },
+                    canPersist: dto.canPersist,
+                    accessTypes: dto.accessTypes,
+                    accessType: dto.accessType,
+                    mode: dto.mode
+                });
+            }
+        }
+        return Promise.resolve();
+    }
+    $unregisterBreakpoints(breakpointIds, functionBreakpointIds, dataBreakpointIds) {
+        breakpointIds.forEach(id => this.debugService.removeBreakpoints(id));
+        functionBreakpointIds.forEach(id => this.debugService.removeFunctionBreakpoints(id));
+        dataBreakpointIds.forEach(id => this.debugService.removeDataBreakpoints(id));
+        return Promise.resolve();
+    }
+    $registerDebugConfigurationProvider(debugType, providerTriggerKind, hasProvide, hasResolve, hasResolve2, handle) {
+        const provider = {
+            type: debugType,
+            triggerKind: providerTriggerKind
+        };
+        if (hasProvide) {
+            provider.provideDebugConfigurations = (folder, token) => {
+                return this._proxy.$provideDebugConfigurations(handle, folder, token);
+            };
+        }
+        if (hasResolve) {
+            provider.resolveDebugConfiguration = (folder, config, token) => {
+                return this._proxy.$resolveDebugConfiguration(handle, folder, config, token);
+            };
+        }
+        if (hasResolve2) {
+            provider.resolveDebugConfigurationWithSubstitutedVariables = (folder, config, token) => {
+                return this._proxy.$resolveDebugConfigurationWithSubstitutedVariables(handle, folder, config, token);
+            };
+        }
+        this._debugConfigurationProviders.set(handle, provider);
+        this._toDispose.add(this.debugService.getConfigurationManager().registerDebugConfigurationProvider(provider));
+        return Promise.resolve(undefined);
+    }
+    $unregisterDebugConfigurationProvider(handle) {
+        const provider = this._debugConfigurationProviders.get(handle);
+        if (provider) {
+            this._debugConfigurationProviders.delete(handle);
+            this.debugService.getConfigurationManager().unregisterDebugConfigurationProvider(provider);
+        }
+    }
+    $registerDebugAdapterDescriptorFactory(debugType, handle) {
+        const provider = {
+            type: debugType,
+            createDebugAdapterDescriptor: session => {
+                return Promise.resolve(this._proxy.$provideDebugAdapter(handle, this.getSessionDto(session)));
+            }
+        };
+        this._debugAdapterDescriptorFactories.set(handle, provider);
+        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterDescriptorFactory(provider));
+        return Promise.resolve(undefined);
+    }
+    $unregisterDebugAdapterDescriptorFactory(handle) {
+        const provider = this._debugAdapterDescriptorFactories.get(handle);
+        if (provider) {
+            this._debugAdapterDescriptorFactories.delete(handle);
+            this.debugService.getAdapterManager().unregisterDebugAdapterDescriptorFactory(provider);
+        }
+    }
+    getSession(sessionId) {
+        if (sessionId) {
+            return this.debugService.getModel().getSession(sessionId, true);
+        }
+        return undefined;
+    }
+    async $startDebugging(folder, nameOrConfig, options) {
+        const folderUri = folder ? URI.revive(folder) : undefined;
+        const launch = this.debugService.getConfigurationManager().getLaunch(folderUri);
+        const parentSession = this.getSession(options.parentSessionID);
+        const saveBeforeStart = typeof options.suppressSaveBeforeStart === 'boolean' ? !options.suppressSaveBeforeStart : undefined;
+        const debugOptions = {
+            noDebug: options.noDebug,
+            parentSession,
+            lifecycleManagedByParent: options.lifecycleManagedByParent,
+            repl: options.repl,
+            compact: options.compact,
+            compoundRoot: parentSession?.compoundRoot,
+            saveBeforeRestart: saveBeforeStart,
+            suppressDebugStatusbar: options.suppressDebugStatusbar,
+            suppressDebugToolbar: options.suppressDebugToolbar,
+            suppressDebugView: options.suppressDebugView,
+        };
+        try {
+            return this.debugService.startDebugging(launch, nameOrConfig, debugOptions, saveBeforeStart);
+        }
+        catch (err) {
+            throw new ErrorNoTelemetry(err && err.message ? err.message : 'cannot start debugging');
+        }
+    }
+    $setDebugSessionName(sessionId, name) {
+        const session = this.debugService.getModel().getSession(sessionId);
+        session?.setName(name);
+    }
+    $customDebugAdapterRequest(sessionId, request, args) {
+        const session = this.debugService.getModel().getSession(sessionId, true);
+        if (session) {
+            return session.customRequest(request, args).then(response => {
+                if (response && response.success) {
+                    return response.body;
+                }
+                else {
+                    return Promise.reject(( new ErrorNoTelemetry(response ? response.message : 'custom request failed')));
+                }
+            });
+        }
+        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+    }
+    $getDebugProtocolBreakpoint(sessionId, breakpoinId) {
+        const session = this.debugService.getModel().getSession(sessionId, true);
+        if (session) {
+            return Promise.resolve(session.getDebugProtocolBreakpoint(breakpoinId));
+        }
+        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+    }
+    $stopDebugging(sessionId) {
+        if (sessionId) {
+            const session = this.debugService.getModel().getSession(sessionId, true);
+            if (session) {
+                return this.debugService.stopSession(session, isSessionAttach(session));
+            }
+        }
+        else {
+            return this.debugService.stopSession(undefined);
+        }
+        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+    }
+    $appendDebugConsole(value) {
+        const session = this.debugService.getViewModel().focusedSession;
+        session?.appendToRepl({ output: value, sev: Severity$1.Warning });
+    }
+    $acceptDAMessage(handle, message) {
+        this.getDebugAdapter(handle).acceptMessage(convertToVSCPaths(message, false));
+    }
+    $acceptDAError(handle, name, message, stack) {
+        this.getDebugAdapter(handle).fireError(handle, ( new Error(`${name}: ${message}\n${stack}`)));
+    }
+    $acceptDAExit(handle, code, signal) {
+        this.getDebugAdapter(handle).fireExit(handle, code, signal);
+    }
+    getDebugAdapter(handle) {
+        const adapter = this._debugAdapters.get(handle);
+        if (!adapter) {
+            throw new Error('Invalid debug adapter');
+        }
+        return adapter;
+    }
+    $sessionCached(sessionID) {
+        this._extHostKnownSessions.add(sessionID);
+    }
+    getSessionDto(session) {
+        if (session) {
+            const sessionID = session.getId();
+            if (( this._extHostKnownSessions.has(sessionID))) {
+                return sessionID;
+            }
+            else {
+                return {
+                    id: sessionID,
+                    type: session.configuration.type,
+                    name: session.name,
+                    folderUri: session.root ? session.root.uri : undefined,
+                    configuration: session.configuration,
+                    parent: session.parentSession?.getId(),
+                };
+            }
+        }
+        return undefined;
+    }
+    convertToDto(bps) {
+        return ( bps.map(bp => {
+            if ('name' in bp) {
+                const fbp = bp;
+                return {
+                    type: 'function',
+                    id: fbp.getId(),
+                    enabled: fbp.enabled,
+                    condition: fbp.condition,
+                    hitCondition: fbp.hitCondition,
+                    logMessage: fbp.logMessage,
+                    functionName: fbp.name
+                };
+            }
+            else if ('src' in bp) {
+                const dbp = bp;
+                return {
+                    type: 'data',
+                    id: dbp.getId(),
+                    dataId: dbp.src.type === 0  ? dbp.src.dataId : dbp.src.address,
+                    enabled: dbp.enabled,
+                    condition: dbp.condition,
+                    hitCondition: dbp.hitCondition,
+                    logMessage: dbp.logMessage,
+                    accessType: dbp.accessType,
+                    label: dbp.description,
+                    canPersist: dbp.canPersist
+                };
+            }
+            else {
+                const sbp = bp;
+                return {
+                    type: 'source',
+                    id: sbp.getId(),
+                    enabled: sbp.enabled,
+                    condition: sbp.condition,
+                    hitCondition: sbp.hitCondition,
+                    logMessage: sbp.logMessage,
+                    uri: sbp.uri,
+                    line: sbp.lineNumber > 0 ? sbp.lineNumber - 1 : 0,
+                    character: (typeof sbp.column === 'number' && sbp.column > 0) ? sbp.column - 1 : 0,
+                };
+            }
+        }));
+    }
+};
+MainThreadDebugService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDebugService),
+    ( __param(1, IDebugService)),
+    ( __param(2, IDebugVisualizerService))
+], MainThreadDebugService);
+class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
+    constructor(_ds, _handle, _proxy, session) {
+        super();
+        this._ds = _ds;
+        this._handle = _handle;
+        this._proxy = _proxy;
+        this.session = session;
+    }
+    fireError(handle, err) {
+        this._onError.fire(err);
+    }
+    fireExit(handle, code, signal) {
+        this._onExit.fire(code);
+    }
+    startSession() {
+        return Promise.resolve(this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this.session)));
+    }
+    sendMessage(message) {
+        this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, true));
+    }
+    async stopSession() {
+        await this.cancelPendingRequests();
+        return Promise.resolve(this._proxy.$stopDASession(this._handle));
+    }
+}
+export { MainThreadDebugService };

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

@@ -0,0 +1,100 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { URI } from '../../../base/common/uri.js';
+import { Emitter } from '../../../base/common/event.js';
+import { dispose } from '../../../base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IDecorationsService } from '../../services/decorations/common/decorations.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+class DecorationRequestsQueue {
+    constructor(_proxy, _handle) {
+        this._proxy = _proxy;
+        this._handle = _handle;
+        this._idPool = 0;
+        this._requests = ( new Map());
+        this._resolver = ( new Map());
+    }
+    enqueue(uri, token) {
+        const id = ++this._idPool;
+        const result = ( new Promise(resolve => {
+            this._requests.set(id, { id, uri });
+            this._resolver.set(id, resolve);
+            this._processQueue();
+        }));
+        const sub = token.onCancellationRequested(() => {
+            this._requests.delete(id);
+            this._resolver.delete(id);
+        });
+        return result.finally(() => sub.dispose());
+    }
+    _processQueue() {
+        if (typeof this._timer === 'number') {
+            return;
+        }
+        this._timer = setTimeout(() => {
+            const requests = this._requests;
+            const resolver = this._resolver;
+            this._proxy.$provideDecorations(this._handle, [...( requests.values())], CancellationToken.None).then(data => {
+                for (const [id, resolve] of resolver) {
+                    resolve(data[id]);
+                }
+            });
+            this._requests = ( new Map());
+            this._resolver = ( new Map());
+            this._timer = undefined;
+        }, 0);
+    }
+}
+let MainThreadDecorations = class MainThreadDecorations {
+    constructor(context, _decorationsService) {
+        this._decorationsService = _decorationsService;
+        this._provider = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostDecorations));
+    }
+    dispose() {
+        this._provider.forEach(value => dispose(value));
+        this._provider.clear();
+    }
+    $registerDecorationProvider(handle, label) {
+        const emitter = ( new Emitter());
+        const queue = ( new DecorationRequestsQueue(this._proxy, handle));
+        const registration = this._decorationsService.registerDecorationsProvider({
+            label,
+            onDidChange: emitter.event,
+            provideDecorations: async (uri, token) => {
+                const data = await queue.enqueue(uri, token);
+                if (!data) {
+                    return undefined;
+                }
+                const [bubble, tooltip, letter, themeColor] = data;
+                return {
+                    weight: 10,
+                    bubble: bubble ?? false,
+                    color: themeColor?.id,
+                    tooltip,
+                    letter
+                };
+            }
+        });
+        this._provider.set(handle, [emitter, registration]);
+    }
+    $onDidChange(handle, resources) {
+        const provider = this._provider.get(handle);
+        if (provider) {
+            const [emitter] = provider;
+            emitter.fire(resources && ( resources.map(r => URI.revive(r))));
+        }
+    }
+    $unregisterDecorationProvider(handle) {
+        const provider = this._provider.get(handle);
+        if (provider) {
+            dispose(provider);
+            this._provider.delete(handle);
+        }
+    }
+};
+MainThreadDecorations = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDecorations),
+    ( __param(1, IDecorationsService))
+], MainThreadDecorations);
+export { MainThreadDecorations };

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

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { IMarkerService } from '../../../platform/markers/common/markers.js';
+import { URI } from '../../../base/common/uri.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IUriIdentityService } from '../../../platform/uriIdentity/common/uriIdentity.js';
+let MainThreadDiagnostics = class MainThreadDiagnostics {
+    constructor(extHostContext, _markerService, _uriIdentService) {
+        this._markerService = _markerService;
+        this._uriIdentService = _uriIdentService;
+        this._activeOwners = ( new Set());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDiagnostics));
+        this._markerListener = this._markerService.onMarkerChanged(this._forwardMarkers, this);
+    }
+    dispose() {
+        this._markerListener.dispose();
+        this._activeOwners.forEach(owner => this._markerService.changeAll(owner, []));
+        this._activeOwners.clear();
+    }
+    _forwardMarkers(resources) {
+        const data = [];
+        for (const resource of resources) {
+            const allMarkerData = this._markerService.read({ resource });
+            if (allMarkerData.length === 0) {
+                data.push([resource, []]);
+            }
+            else {
+                const forgeinMarkerData = allMarkerData.filter(marker => !( this._activeOwners.has(marker.owner)));
+                if (forgeinMarkerData.length > 0) {
+                    data.push([resource, forgeinMarkerData]);
+                }
+            }
+        }
+        if (data.length > 0) {
+            this._proxy.$acceptMarkersChange(data);
+        }
+    }
+    $changeMany(owner, entries) {
+        for (const entry of entries) {
+            const [uri, markers] = entry;
+            if (markers) {
+                for (const marker of markers) {
+                    if (marker.relatedInformation) {
+                        for (const relatedInformation of marker.relatedInformation) {
+                            relatedInformation.resource = URI.revive(relatedInformation.resource);
+                        }
+                    }
+                    if (marker.code && typeof marker.code !== 'string') {
+                        marker.code.target = URI.revive(marker.code.target);
+                    }
+                }
+            }
+            this._markerService.changeOne(owner, this._uriIdentService.asCanonicalUri(URI.revive(uri)), markers);
+        }
+        this._activeOwners.add(owner);
+    }
+    $clear(owner) {
+        this._markerService.changeAll(owner, []);
+        this._activeOwners.delete(owner);
+    }
+};
+MainThreadDiagnostics = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDiagnostics),
+    ( __param(1, IMarkerService)),
+    ( __param(2, IUriIdentityService))
+], MainThreadDiagnostics);
+export { MainThreadDiagnostics };

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

@@ -0,0 +1,66 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { URI } from '../../../base/common/uri.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 { Schemas } from '../../../base/common/network.js';
+import { IFileDialogService } from '../../../platform/dialogs/common/dialogs.js';
+var MainThreadDialogs_1;
+let MainThreadDialogs = MainThreadDialogs_1 = class MainThreadDialogs {
+    constructor(context, _fileDialogService) {
+        this._fileDialogService = _fileDialogService;
+    }
+    dispose() {
+    }
+    async $showOpenDialog(options) {
+        const convertedOptions = MainThreadDialogs_1._convertOpenOptions(options);
+        if (!convertedOptions.defaultUri) {
+            convertedOptions.defaultUri = await this._fileDialogService.defaultFilePath();
+        }
+        return Promise.resolve(this._fileDialogService.showOpenDialog(convertedOptions));
+    }
+    async $showSaveDialog(options) {
+        const convertedOptions = MainThreadDialogs_1._convertSaveOptions(options);
+        if (!convertedOptions.defaultUri) {
+            convertedOptions.defaultUri = await this._fileDialogService.defaultFilePath();
+        }
+        return Promise.resolve(this._fileDialogService.showSaveDialog(convertedOptions));
+    }
+    static _convertOpenOptions(options) {
+        const result = {
+            openLabel: options?.openLabel || undefined,
+            canSelectFiles: options?.canSelectFiles || (!options?.canSelectFiles && !options?.canSelectFolders),
+            canSelectFolders: options?.canSelectFolders,
+            canSelectMany: options?.canSelectMany,
+            defaultUri: options?.defaultUri ? URI.revive(options.defaultUri) : undefined,
+            title: options?.title || undefined,
+            availableFileSystems: options?.allowUIResources ? [Schemas.vscodeRemote, Schemas.file] : []
+        };
+        if (options?.filters) {
+            result.filters = [];
+            for (const [key, value] of Object.entries(options.filters)) {
+                result.filters.push({ name: key, extensions: value });
+            }
+        }
+        return result;
+    }
+    static _convertSaveOptions(options) {
+        const result = {
+            defaultUri: options?.defaultUri ? URI.revive(options.defaultUri) : undefined,
+            saveLabel: options?.saveLabel || undefined,
+            title: options?.title || undefined
+        };
+        if (options?.filters) {
+            result.filters = [];
+            for (const [key, value] of Object.entries(options.filters)) {
+                result.filters.push({ name: key, extensions: value });
+            }
+        }
+        return result;
+    }
+};
+MainThreadDialogs = MainThreadDialogs_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDialogs),
+    ( __param(1, IFileDialogService))
+], MainThreadDialogs);
+export { MainThreadDialogs };