@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -39,9 +39,16 @@ let MainThreadDebugService = class MainThreadDebugService {
                 store = ( new DisposableStore());
                 sessionListeners.set(session, store);
             }
-            store.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
+            store.add(session.onDidCustomEvent(
+                event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)
+            ));
         }));
-        this._toDispose.add(debugService.onDidEndSession(({ session, restart }) => {
+        this._toDispose.add(debugService.onDidEndSession((
+            {
+                session,
+                restart
+            }
+        ) => {
             this._proxy.$acceptDebugSessionTerminated(this.getSessionDto(session));
             this._extHostKnownSessions.delete(session.getId());
             if (!restart) {
@@ -58,7 +65,7 @@ let MainThreadDebugService = class MainThreadDebugService {
         }));
         this._toDispose.add(toDisposable(() => {
             for (const [handle, da] of this._debugAdapters) {
-                da.fireError(handle, ( new Error('Extension host shut down')));
+                da.fireError(handle, ( new Error("Extension host shut down")));
             }
         }));
         this._debugAdapters = ( new Map());
@@ -66,28 +73,28 @@ let MainThreadDebugService = class MainThreadDebugService {
         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._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) {
@@ -109,7 +116,7 @@ let MainThreadDebugService = class MainThreadDebugService {
             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),
+            resolveDebugVisualizer: (viz, token) => this._proxy.$resolveDebugVisualizer(viz.id, token)
         });
         this._visualizerHandles.set(`${extensionId}/${id}`, handle);
     }
@@ -161,12 +168,14 @@ let MainThreadDebugService = class MainThreadDebugService {
         return this._proxy.$runInTerminal(args, sessionId);
     }
     $registerDebugTypes(debugTypes) {
-        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterFactory(debugTypes, this));
+        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) => ({
+            if (dto.type === "sourceMulti") {
+                const rawbps = ( dto.lines.map(l => ({
                     id: l.id,
                     enabled: l.enabled,
                     lineNumber: l.line + 1,
@@ -174,11 +183,10 @@ let MainThreadDebugService = class MainThreadDebugService {
                     condition: l.condition,
                     hitCondition: l.hitCondition,
                     logMessage: l.logMessage,
-                    mode: l.mode,
+                    mode: l.mode
                 })));
                 this.debugService.addBreakpoints(URI.revive(dto.uri), rawbps);
-            }
-            else if (dto.type === 'function') {
+            } else if (dto.type === "function") {
                 this.debugService.addFunctionBreakpoint({
                     name: dto.functionName,
                     mode: dto.mode,
@@ -187,11 +195,13 @@ let MainThreadDebugService = class MainThreadDebugService {
                     enabled: dto.enabled,
                     logMessage: dto.logMessage
                 }, dto.id);
-            }
-            else if (dto.type === 'data') {
+            } else if (dto.type === "data") {
                 this.debugService.addDataBreakpoint({
                     description: dto.label,
-                    src: { type: DataBreakpointSetType.Variable, dataId: dto.dataId },
+                    src: {
+                        type: DataBreakpointSetType.Variable,
+                        dataId: dto.dataId
+                    },
                     canPersist: dto.canPersist,
                     accessTypes: dto.accessTypes,
                     accessType: dto.accessType,
@@ -207,7 +217,14 @@ let MainThreadDebugService = class MainThreadDebugService {
         dataBreakpointIds.forEach(id => this.debugService.removeDataBreakpoints(id));
         return Promise.resolve();
     }
-    $registerDebugConfigurationProvider(debugType, providerTriggerKind, hasProvide, hasResolve, hasResolve2, handle) {
+    $registerDebugConfigurationProvider(
+        debugType,
+        providerTriggerKind,
+        hasProvide,
+        hasResolve,
+        hasResolve2,
+        handle
+    ) {
         const provider = {
             type: debugType,
             triggerKind: providerTriggerKind
@@ -228,7 +245,9 @@ let MainThreadDebugService = class MainThreadDebugService {
             };
         }
         this._debugConfigurationProviders.set(handle, provider);
-        this._toDispose.add(this.debugService.getConfigurationManager().registerDebugConfigurationProvider(provider));
+        this._toDispose.add(
+            this.debugService.getConfigurationManager().registerDebugConfigurationProvider(provider)
+        );
         return Promise.resolve(undefined);
     }
     $unregisterDebugConfigurationProvider(handle) {
@@ -246,7 +265,9 @@ let MainThreadDebugService = class MainThreadDebugService {
             }
         };
         this._debugAdapterDescriptorFactories.set(handle, provider);
-        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterDescriptorFactory(provider));
+        this._toDispose.add(
+            this.debugService.getAdapterManager().registerDebugAdapterDescriptorFactory(provider)
+        );
         return Promise.resolve(undefined);
     }
     $unregisterDebugAdapterDescriptorFactory(handle) {
@@ -266,7 +287,7 @@ let MainThreadDebugService = class MainThreadDebugService {
         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 saveBeforeStart = typeof options.suppressSaveBeforeStart === "boolean" ? !options.suppressSaveBeforeStart : undefined;
         const debugOptions = {
             noDebug: options.noDebug,
             parentSession,
@@ -278,13 +299,12 @@ let MainThreadDebugService = class MainThreadDebugService {
             testRun: options.testRun,
             suppressDebugStatusbar: options.suppressDebugStatusbar,
             suppressDebugToolbar: options.suppressDebugToolbar,
-            suppressDebugView: options.suppressDebugView,
+            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'));
+        } catch (err) {
+            throw ( new ErrorNoTelemetry(err && err.message ? err.message : "cannot start debugging"));
         }
     }
     $setDebugSessionName(sessionId, name) {
@@ -297,20 +317,19 @@ let MainThreadDebugService = class MainThreadDebugService {
             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')));
+                } else {
+                    return Promise.reject(( new ErrorNoTelemetry(response ? response.message : "custom request failed")));
                 }
             });
         }
-        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+        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')));
+        return Promise.reject(( new ErrorNoTelemetry("debug session not found")));
     }
     $stopDebugging(sessionId) {
         if (sessionId) {
@@ -318,15 +337,17 @@ let MainThreadDebugService = class MainThreadDebugService {
             if (session) {
                 return this.debugService.stopSession(session, isSessionAttach(session));
             }
-        }
-        else {
+        } else {
             return this.debugService.stopSession(undefined);
         }
-        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+        return Promise.reject(( new ErrorNoTelemetry("debug session not found")));
     }
     $appendDebugConsole(value) {
         const session = this.debugService.getViewModel().focusedSession;
-        session?.appendToRepl({ output: value, sev: Severity.Warning });
+        session?.appendToRepl({
+            output: value,
+            sev: Severity.Warning
+        });
     }
     $acceptDAMessage(handle, message) {
         this.getDebugAdapter(handle).acceptMessage(convertToVSCPaths(message, false));
@@ -340,7 +361,7 @@ let MainThreadDebugService = class MainThreadDebugService {
     getDebugAdapter(handle) {
         const adapter = this._debugAdapters.get(handle);
         if (!adapter) {
-            throw ( new Error('Invalid debug adapter'));
+            throw ( new Error("Invalid debug adapter"));
         }
         return adapter;
     }
@@ -352,15 +373,14 @@ let MainThreadDebugService = class MainThreadDebugService {
             const sessionID = session.getId();
             if (( this._extHostKnownSessions.has(sessionID))) {
                 return sessionID;
-            }
-            else {
+            } 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(),
+                    parent: session.parentSession?.getId()
                 };
             }
         }
@@ -368,10 +388,10 @@ let MainThreadDebugService = class MainThreadDebugService {
     }
     convertToDto(bps) {
         return ( bps.map(bp => {
-            if ('name' in bp) {
+            if ("name" in bp) {
                 const fbp = bp;
                 return {
-                    type: 'function',
+                    type: "function",
                     id: fbp.getId(),
                     enabled: fbp.enabled,
                     condition: fbp.condition,
@@ -379,11 +399,10 @@ let MainThreadDebugService = class MainThreadDebugService {
                     logMessage: fbp.logMessage,
                     functionName: fbp.name
                 };
-            }
-            else if ('src' in bp) {
+            } else if ("src" in bp) {
                 const dbp = bp;
                 return {
-                    type: 'data',
+                    type: "data",
                     id: dbp.getId(),
                     dataId: dbp.src.type === DataBreakpointSetType.Variable ? dbp.src.dataId : dbp.src.address,
                     enabled: dbp.enabled,
@@ -394,11 +413,10 @@ let MainThreadDebugService = class MainThreadDebugService {
                     label: dbp.description,
                     canPersist: dbp.canPersist
                 };
-            }
-            else if ('uri' in bp) {
+            } else if ("uri" in bp) {
                 const sbp = bp;
                 return {
-                    type: 'source',
+                    type: "source",
                     id: sbp.getId(),
                     enabled: sbp.enabled,
                     condition: sbp.condition,
@@ -406,20 +424,15 @@ let MainThreadDebugService = class MainThreadDebugService {
                     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,
+                    character: (typeof sbp.column === "number" && sbp.column > 0) ? sbp.column - 1 : 0
                 };
-            }
-            else {
+            } else {
                 return undefined;
             }
         })).filter(isDefined);
     }
 };
-MainThreadDebugService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDebugService),
-    ( __param(1, IDebugService)),
-    ( __param(2, IDebugVisualizerService))
-], MainThreadDebugService);
+MainThreadDebugService = __decorate([extHostNamedCustomer(MainContext.MainThreadDebugService), ( __param(1, IDebugService)), ( __param(2, IDebugVisualizerService))], MainThreadDebugService);
 class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
     constructor(_ds, _handle, _proxy, session) {
         super();
@@ -435,7 +448,9 @@ class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
         this._onExit.fire(code);
     }
     startSession() {
-        return Promise.resolve(this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this.session)));
+        return Promise.resolve(
+            this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this.session))
+        );
     }
     sendMessage(message) {
         this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, true));

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

@@ -21,7 +21,10 @@ class DecorationRequestsQueue {
     enqueue(uri, token) {
         const id = ++this._idPool;
         const defer = ( new DeferredPromise());
-        this._requests.set(id, { id, uri });
+        this._requests.set(id, {
+            id,
+            uri
+        });
         this._resolver.set(id, defer);
         this._processQueue();
         const sub = token.onCancellationRequested(() => {
@@ -97,9 +100,6 @@ let MainThreadDecorations = class MainThreadDecorations {
         }
     }
 };
-MainThreadDecorations = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDecorations),
-    ( __param(1, IDecorationsService))
-], MainThreadDecorations);
+MainThreadDecorations = __decorate([extHostNamedCustomer(MainContext.MainThreadDecorations), ( __param(1, IDecorationsService))], MainThreadDecorations);
 
 export { MainThreadDecorations };

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

@@ -9,8 +9,12 @@ import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 
 var MainThreadDiagnostics_1;
 let MainThreadDiagnostics = class MainThreadDiagnostics {
-    static { MainThreadDiagnostics_1 = this; }
-    static { this.ExtHostCounter = 1; }
+    static {
+        MainThreadDiagnostics_1 = this;
+    }
+    static {
+        this.ExtHostCounter = 1;
+    }
     constructor(extHostContext, _markerService, _uriIdentService) {
         this._markerService = _markerService;
         this._uriIdentService = _uriIdentService;
@@ -23,7 +27,9 @@ let MainThreadDiagnostics = class MainThreadDiagnostics {
         this._markerListener.dispose();
         for (const owner of this._activeOwners) {
             const markersData = ( new ResourceMap());
-            for (const marker of this._markerService.read({ owner })) {
+            for (const marker of this._markerService.read({
+                owner
+            })) {
                 let data = markersData.get(marker.resource);
                 if (data === undefined) {
                     data = [];
@@ -42,11 +48,13 @@ let MainThreadDiagnostics = class MainThreadDiagnostics {
     _forwardMarkers(resources) {
         const data = [];
         for (const resource of resources) {
-            const allMarkerData = this._markerService.read({ resource, ignoreResourceFilters: true });
+            const allMarkerData = this._markerService.read({
+                resource,
+                ignoreResourceFilters: true
+            });
             if (allMarkerData.length === 0) {
                 data.push([resource, []]);
-            }
-            else {
+            } else {
                 const foreignMarkerData = allMarkerData.filter(marker => marker?.origin !== this.extHostId);
                 if (foreignMarkerData.length > 0) {
                     data.push([resource, foreignMarkerData]);
@@ -67,7 +75,7 @@ let MainThreadDiagnostics = class MainThreadDiagnostics {
                             relatedInformation.resource = URI.revive(relatedInformation.resource);
                         }
                     }
-                    if (marker.code && typeof marker.code !== 'string') {
+                    if (marker.code && typeof marker.code !== "string") {
                         marker.code.target = URI.revive(marker.code.target);
                     }
                     if (marker.origin === undefined) {
@@ -84,10 +92,6 @@ let MainThreadDiagnostics = class MainThreadDiagnostics {
         this._activeOwners.delete(owner);
     }
 };
-MainThreadDiagnostics = MainThreadDiagnostics_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDiagnostics),
-    ( __param(1, IMarkerService)),
-    ( __param(2, IUriIdentityService))
-], MainThreadDiagnostics);
+MainThreadDiagnostics = MainThreadDiagnostics_1 = __decorate([extHostNamedCustomer(MainContext.MainThreadDiagnostics), ( __param(1, IMarkerService)), ( __param(2, IUriIdentityService))], MainThreadDiagnostics);
 
 export { MainThreadDiagnostics };

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

@@ -10,8 +10,7 @@ let MainThreadDialogs = MainThreadDialogs_1 = class MainThreadDialogs {
     constructor(context, _fileDialogService) {
         this._fileDialogService = _fileDialogService;
     }
-    dispose() {
-    }
+    dispose() {}
     async $showOpenDialog(options) {
         const convertedOptions = MainThreadDialogs_1._convertOpenOptions(options);
         if (!convertedOptions.defaultUri) {
@@ -39,7 +38,10 @@ let MainThreadDialogs = MainThreadDialogs_1 = class MainThreadDialogs {
         if (options?.filters) {
             result.filters = [];
             for (const [key, value] of Object.entries(options.filters)) {
-                result.filters.push({ name: key, extensions: value });
+                result.filters.push({
+                    name: key,
+                    extensions: value
+                });
             }
         }
         return result;
@@ -53,15 +55,15 @@ let MainThreadDialogs = MainThreadDialogs_1 = class MainThreadDialogs {
         if (options?.filters) {
             result.filters = [];
             for (const [key, value] of Object.entries(options.filters)) {
-                result.filters.push({ name: key, extensions: value });
+                result.filters.push({
+                    name: key,
+                    extensions: value
+                });
             }
         }
         return result;
     }
 };
-MainThreadDialogs = MainThreadDialogs_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDialogs),
-    ( __param(1, IFileDialogService))
-], MainThreadDialogs);
+MainThreadDialogs = MainThreadDialogs_1 = __decorate([extHostNamedCustomer(MainContext.MainThreadDialogs), ( __param(1, IFileDialogService))], MainThreadDialogs);
 
 export { MainThreadDialogs };

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

@@ -14,7 +14,13 @@ import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode
 import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 
 let MainThreadDocumentContentProviders = class MainThreadDocumentContentProviders {
-    constructor(extHostContext, _textModelResolverService, _languageService, _modelService, _editorWorkerService) {
+    constructor(
+        extHostContext,
+        _textModelResolverService,
+        _languageService,
+        _modelService,
+        _editorWorkerService
+    ) {
         this._textModelResolverService = _textModelResolverService;
         this._languageService = _languageService;
         this._modelService = _modelService;
@@ -29,9 +35,9 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
     }
     $registerTextContentProvider(handle, scheme) {
         const registration = this._textModelResolverService.registerTextModelContentProvider(scheme, {
-            provideTextContent: (uri) => {
+            provideTextContent: uri => {
                 return this._proxy.$provideTextDocumentContent(handle, uri).then(value => {
-                    if (typeof value === 'string') {
+                    if (typeof value === "string") {
                         const firstLineText = value.substr(0, 1 + value.search(/\r?\n/));
                         const languageSelection = this._languageService.createByFilepathOrFirstLine(uri, firstLineText);
                         return this._modelService.createModel(value, languageSelection, uri);
@@ -55,7 +61,10 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
         const myToken = ( new CancellationTokenSource());
         this._pendingUpdate.set(model.id, myToken);
         try {
-            const edits = await this._editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: value, range: model.getFullModelRange() }]);
+            const edits = await this._editorWorkerService.computeMoreMinimalEdits(model.uri, [{
+                text: value,
+                range: model.getFullModelRange()
+            }]);
             this._pendingUpdate.delete(model.id);
             if (myToken.token.isCancellationRequested) {
                 return;
@@ -66,8 +75,7 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
             if (edits && edits.length > 0) {
                 model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
             }
-        }
-        catch (error) {
+        } catch (error) {
             onUnexpectedError(error);
         }
     }