@codingame/monaco-vscode-workbench-service-override 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/browser/parts/notifications/notificationAccessibleView.js

@@ -16,7 +16,7 @@ import { withSeverityPrefix } from '@codingame/monaco-vscode-api/vscode/vs/platf
 class NotificationAccessibleView {
     constructor() {
         this.priority = 90;
-        this.name = 'notifications';
+        this.name = "notifications";
         this.when = NotificationFocusedContext;
         this.type = AccessibleViewType.View;
     }
@@ -30,7 +30,7 @@ class NotificationAccessibleView {
             if (!notification) {
                 return;
             }
-            commandService.executeCommand('notifications.showList');
+            commandService.executeCommand("notifications.showList");
             let notificationIndex;
             const list = listService.lastFocusedList;
             if (list instanceof WorkbenchList) {
@@ -40,13 +40,12 @@ class NotificationAccessibleView {
                 return;
             }
             function focusList() {
-                commandService.executeCommand('notifications.showList');
+                commandService.executeCommand("notifications.showList");
                 if (list && notificationIndex !== undefined) {
                     list.domFocus();
                     try {
                         list.setFocus([notificationIndex]);
-                    }
-                    catch { }
+                    } catch {}
                 }
             }
             function getContentForNotification() {
@@ -55,38 +54,30 @@ class NotificationAccessibleView {
                 if (!notification || !message) {
                     return;
                 }
-                return withSeverityPrefix(notification.source ? ( localize(3524, '{0} Source: {1}', message, notification.source)) : message, notification.severity);
+                return withSeverityPrefix(notification.source ? ( localize(3528, "{0} Source: {1}", message, notification.source)) : message, notification.severity);
             }
             const content = getContentForNotification();
             if (!content) {
                 return;
             }
             notification.onDidClose(() => accessibleViewService.next());
-            return ( new AccessibleContentProvider(
-                AccessibleViewProviderId.Notification,
-                { type: AccessibleViewType.View },
-                () => content,
-                () => focusList(),
-                'accessibility.verbosity.notification',
-                undefined,
-                getActionsFromNotification(notification, accessibilitySignalService),
-                () => {
-                    if (!list) {
-                        return;
-                    }
-                    focusList();
-                    list.focusNext();
-                    return getContentForNotification();
-                },
-                () => {
-                    if (!list) {
-                        return;
-                    }
-                    focusList();
-                    list.focusPrevious();
-                    return getContentForNotification();
+            return ( new AccessibleContentProvider(AccessibleViewProviderId.Notification, {
+                type: AccessibleViewType.View
+            }, () => content, () => focusList(), "accessibility.verbosity.notification", undefined, getActionsFromNotification(notification, accessibilitySignalService), () => {
+                if (!list) {
+                    return;
+                }
+                focusList();
+                list.focusNext();
+                return getContentForNotification();
+            }, () => {
+                if (!list) {
+                    return;
                 }
-            ));
+                focusList();
+                list.focusPrevious();
+                return getContentForNotification();
+            }));
         }
         return getProvider();
     }
@@ -112,16 +103,21 @@ function getActionsFromNotification(notification, accessibilitySignalService) {
             };
         }
     }
-    const manageExtension = actions?.find(a => a.label.includes('Manage Extension'));
+    const manageExtension = actions?.find(a => a.label.includes("Manage Extension"));
     if (manageExtension) {
         manageExtension.class = ThemeIcon.asClassName(Codicon.gear);
     }
     if (actions) {
         actions.push({
-            id: 'clearNotification', label: ( localize(3525, "Clear Notification")), tooltip: ( localize(3525, "Clear Notification")), run: () => {
+            id: "clearNotification",
+            label: ( localize(3529, "Clear Notification")),
+            tooltip: ( localize(3529, "Clear Notification")),
+            run: () => {
                 notification.close();
                 accessibilitySignalService.playSignal(AccessibilitySignal.clear);
-            }, enabled: true, class: ThemeIcon.asClassName(Codicon.clearAll)
+            },
+            enabled: true,
+            class: ThemeIcon.asClassName(Codicon.clearAll)
         });
     }
     return actions;

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

@@ -3,7 +3,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/style';
 import { createElement, runWhenWindowIdle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { Emitter, setGlobalLeakWarningThreshold, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { timeout, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { isChrome, isFirefox, isSafari } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/browser';
+import { isFirefox, isChrome, isSafari } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/browser';
 import { mark } from '@codingame/monaco-vscode-api/vscode/vs/base/common/performance';
 import { onUnexpectedError, setUnexpectedErrorHandler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { isNative, isMacintosh, isWindows, isLinux, isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
@@ -41,20 +41,29 @@ import { EditorMarkdownCodeBlockRenderer } from '@codingame/monaco-vscode-api/vs
 
 class Workbench extends Layout {
     constructor(parent, options, serviceCollection, logService) {
-        super(parent, { resetLayout: options?.resetLayout, customEditorRestore: options?.customEditorRestore });
+        super(parent, {
+            resetLayout: options?.resetLayout,
+            customEditorRestore: options?.customEditorRestore
+        });
         this.options = options;
         this.serviceCollection = serviceCollection;
         this._onWillShutdown = this._register(( new Emitter()));
         this.onWillShutdown = this._onWillShutdown.event;
         this._onDidShutdown = this._register(( new Emitter()));
         this.onDidShutdown = this._onDidShutdown.event;
-        this.previousUnexpectedError = { message: undefined, time: 0 };
-        mark('code/willStartWorkbench');
+        this.previousUnexpectedError = {
+            message: undefined,
+            time: 0
+        };
+        mark("code/willStartWorkbench");
         this.registerErrorHandler(logService);
         this.parent.appendChild(this.mainContainer);
     }
     registerErrorHandler(logService) {
-        mainWindow.addEventListener('unhandledrejection', (event) => {
+        if (!isFirefox) {
+            Error.stackTraceLimit = 100;
+        }
+        mainWindow.addEventListener("unhandledrejection", event => {
             onUnexpectedError(event.reason);
             event.preventDefault();
         });
@@ -87,15 +96,25 @@ class Workbench extends Layout {
                 const markdownRendererService = accessor.get(IMarkdownRendererService);
                 markdownRendererService.setDefaultCodeBlockRenderer(instantiationService.createInstance(EditorMarkdownCodeBlockRenderer));
                 this.initLayout(accessor);
-                this.registerListeners(lifecycleService, storageService, configurationService, hostService, dialogService);
-                this.renderWorkbench(instantiationService, notificationService, storageService, configurationService);
+                this.registerListeners(
+                    lifecycleService,
+                    storageService,
+                    configurationService,
+                    hostService,
+                    dialogService
+                );
+                this.renderWorkbench(
+                    instantiationService,
+                    notificationService,
+                    storageService,
+                    configurationService
+                );
                 this.createWorkbenchLayout();
                 this.layout();
                 this.restore(instantiationService, lifecycleService);
             });
             return instantiationService;
-        }
-        catch (error) {
+        } catch (error) {
             onUnexpectedError(error);
             throw error;
         }
@@ -110,23 +129,30 @@ class Workbench extends Layout {
         instantiationService.invokeFunction(accessor => {
             const lifecycleService = accessor.get(ILifecycleService);
             const configurationService = accessor.get(IConfigurationService);
-            if (configurationService && 'acquireInstantiationService' in configurationService) {
+            if (configurationService && "acquireInstantiationService" in configurationService) {
                 configurationService.acquireInstantiationService(instantiationService);
             }
             lifecycleService.phase = LifecyclePhase.Ready;
         });
         return instantiationService;
     }
-    registerListeners(lifecycleService, storageService, configurationService, hostService, dialogService) {
-        this._register(configurationService.onDidChangeConfiguration(e => this.updateFontAliasing(e, configurationService)));
+    registerListeners(
+        lifecycleService,
+        storageService,
+        configurationService,
+        hostService,
+        dialogService
+    ) {
+        this._register(
+            configurationService.onDidChangeConfiguration(e => this.updateFontAliasing(e, configurationService))
+        );
         if (isNative) {
             this._register(storageService.onWillSaveState(e => {
                 if (e.reason === WillSaveStateReason.SHUTDOWN) {
                     this.storeFontInfo(storageService);
                 }
             }));
-        }
-        else {
+        } else {
             this._register(lifecycleService.onWillShutdown(() => this.storeFontInfo(storageService)));
         }
         this._register(lifecycleService.onWillShutdown(event => this._onWillShutdown.fire(event)));
@@ -139,72 +165,128 @@ class Workbench extends Layout {
                 storageService.flush();
             }
         }));
-        this._register(dialogService.onWillShowDialog(() => this.mainContainer.classList.add('modal-dialog-visible')));
-        this._register(dialogService.onDidShowDialog(() => this.mainContainer.classList.remove('modal-dialog-visible')));
+        this._register(
+            dialogService.onWillShowDialog(() => this.mainContainer.classList.add("modal-dialog-visible"))
+        );
+        this._register(
+            dialogService.onDidShowDialog(() => this.mainContainer.classList.remove("modal-dialog-visible"))
+        );
     }
     updateFontAliasing(e, configurationService) {
         if (!isMacintosh) {
             return;
         }
-        if (e && !e.affectsConfiguration('workbench.fontAliasing')) {
+        if (e && !e.affectsConfiguration("workbench.fontAliasing")) {
             return;
         }
-        const aliasing = configurationService.getValue('workbench.fontAliasing');
+        const aliasing = configurationService.getValue("workbench.fontAliasing");
         if (this.fontAliasing === aliasing) {
             return;
         }
         this.fontAliasing = aliasing;
-        const fontAliasingValues = ['antialiased', 'none', 'auto'];
+        const fontAliasingValues = ["antialiased", "none", "auto"];
         this.mainContainer.classList.remove(...( fontAliasingValues.map(value => `monaco-font-aliasing-${value}`)));
         if (( fontAliasingValues.some(option => option === aliasing))) {
             this.mainContainer.classList.add(`monaco-font-aliasing-${aliasing}`);
         }
     }
     restoreFontInfo(storageService, configurationService) {
-        const storedFontInfoRaw = storageService.get('editorFontInfo', StorageScope.APPLICATION);
+        const storedFontInfoRaw = storageService.get("editorFontInfo", StorageScope.APPLICATION);
         if (storedFontInfoRaw) {
             try {
                 const storedFontInfo = JSON.parse(storedFontInfoRaw);
                 if (Array.isArray(storedFontInfo)) {
                     FontMeasurements.restoreFontInfo(mainWindow, storedFontInfo);
                 }
-            }
-            catch (err) {
-            }
+            } catch (err) {}
         }
-        FontMeasurements.readFontInfo(mainWindow, createBareFontInfoFromRawSettings(configurationService.getValue('editor'), PixelRatio.getInstance(mainWindow).value));
+        FontMeasurements.readFontInfo(mainWindow, createBareFontInfoFromRawSettings(
+            configurationService.getValue("editor"),
+            PixelRatio.getInstance(mainWindow).value
+        ));
     }
     storeFontInfo(storageService) {
         const serializedFontInfo = FontMeasurements.serializeFontInfo(mainWindow);
         if (serializedFontInfo) {
-            storageService.store('editorFontInfo', JSON.stringify(serializedFontInfo), StorageScope.APPLICATION, StorageTarget.MACHINE);
+            storageService.store(
+                "editorFontInfo",
+                JSON.stringify(serializedFontInfo),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
         }
     }
-    renderWorkbench(instantiationService, notificationService, storageService, configurationService) {
+    renderWorkbench(
+        instantiationService,
+        notificationService,
+        storageService,
+        configurationService
+    ) {
         setARIAContainer(this.mainContainer);
-        setProgressAccessibilitySignalScheduler((msDelayTime, msLoopTime) => instantiationService.createInstance(AccessibilityProgressSignalScheduler, msDelayTime, msLoopTime));
-        const platformClass = isWindows ? 'windows' : isLinux ? 'linux' : 'mac';
+        setProgressAccessibilitySignalScheduler(
+            (msDelayTime, msLoopTime) => instantiationService.createInstance(AccessibilityProgressSignalScheduler, msDelayTime, msLoopTime)
+        );
+        const platformClass = isWindows ? "windows" : isLinux ? "linux" : "mac";
         const workbenchClasses = coalesce([
-            'monaco-workbench',
+            "monaco-workbench",
             platformClass,
-            isWeb ? 'web' : undefined,
-            isChrome ? 'chromium' : isFirefox ? 'firefox' : isSafari ? 'safari' : undefined,
+            isWeb ? "web" : undefined,
+            isChrome ? "chromium" : isFirefox ? "firefox" : isSafari ? "safari" : undefined,
             ...this.getLayoutClasses(),
             ...(this.options?.extraClasses ? this.options.extraClasses : [])
         ]);
         this.mainContainer.classList.add(...workbenchClasses);
         this.updateFontAliasing(undefined, configurationService);
         this.restoreFontInfo(storageService, configurationService);
-        for (const { id, role, classes, options } of [
-            { id: Parts.TITLEBAR_PART, role: 'none', classes: ['titlebar'] },
-            { id: Parts.BANNER_PART, role: 'banner', classes: ['banner'] },
-            { id: Parts.ACTIVITYBAR_PART, role: 'none', classes: ['activitybar', this.getSideBarPosition() === Position.LEFT ? 'left' : 'right'] },
-            { id: Parts.SIDEBAR_PART, role: 'none', classes: ['sidebar', this.getSideBarPosition() === Position.LEFT ? 'left' : 'right'] },
-            { id: Parts.EDITOR_PART, role: 'main', classes: ['editor'], options: { restorePreviousState: this.willRestoreEditors() } },
-            { id: Parts.PANEL_PART, role: 'none', classes: ['panel', 'basepanel', positionToString(this.getPanelPosition())] },
-            { id: Parts.AUXILIARYBAR_PART, role: 'none', classes: ['auxiliarybar', 'basepanel', this.getSideBarPosition() === Position.LEFT ? 'right' : 'left'] },
-            { id: Parts.STATUSBAR_PART, role: 'status', classes: ['statusbar'] }
-        ]) {
+        for (const {
+            id,
+            role,
+            classes,
+            options
+        } of [{
+            id: Parts.TITLEBAR_PART,
+            role: "none",
+            classes: ["titlebar"]
+        }, {
+            id: Parts.BANNER_PART,
+            role: "banner",
+            classes: ["banner"]
+        },
+        {
+            id: Parts.ACTIVITYBAR_PART,
+            role: "none",
+            classes: [
+                "activitybar",
+                this.getSideBarPosition() === Position.LEFT ? "left" : "right"
+            ]
+        }, {
+            id: Parts.SIDEBAR_PART,
+            role: "none",
+            classes: ["sidebar", this.getSideBarPosition() === Position.LEFT ? "left" : "right"]
+        }, {
+            id: Parts.EDITOR_PART,
+            role: "main",
+            classes: ["editor"],
+            options: {
+                restorePreviousState: this.willRestoreEditors()
+            }
+        }, {
+            id: Parts.PANEL_PART,
+            role: "none",
+            classes: ["panel", "basepanel", positionToString(this.getPanelPosition())]
+        }, {
+            id: Parts.AUXILIARYBAR_PART,
+            role: "none",
+            classes: [
+                "auxiliarybar",
+                "basepanel",
+                this.getSideBarPosition() === Position.LEFT ? "right" : "left"
+            ]
+        }, {
+            id: Parts.STATUSBAR_PART,
+            role: "status",
+            classes: ["statusbar"]
+        }]) {
             const partContainer = this.createPart(id, role, classes);
             mark(`code/willCreatePart/${id}`);
             this.getPart(id).create(partContainer, options);
@@ -213,19 +295,27 @@ class Workbench extends Layout {
         this.createNotificationsHandlers(instantiationService, notificationService);
     }
     createPart(id, role, classes) {
-        const part = createElement(role === 'status' ? 'footer'  : 'div');
-        part.classList.add('part', ...classes);
+        const part = createElement(
+            role === "status" ? "footer"  : "div"
+        );
+        part.classList.add("part", ...classes);
         part.id = id;
-        part.setAttribute('role', role);
-        if (role === 'status') {
-            part.setAttribute('aria-live', 'off');
+        part.setAttribute("role", role);
+        if (role === "status") {
+            part.setAttribute("aria-live", "off");
         }
         return part;
     }
     createNotificationsHandlers(instantiationService, notificationService) {
-        const notificationsCenter = this._register(instantiationService.createInstance(NotificationsCenter, this.mainContainer, notificationService.model));
-        const notificationsToasts = this._register(instantiationService.createInstance(NotificationsToasts, this.mainContainer, notificationService.model));
-        this._register(instantiationService.createInstance(NotificationsAlerts, notificationService.model));
+        const notificationsCenter = this._register(
+            instantiationService.createInstance(NotificationsCenter, this.mainContainer, notificationService.model)
+        );
+        const notificationsToasts = this._register(
+            instantiationService.createInstance(NotificationsToasts, this.mainContainer, notificationService.model)
+        );
+        this._register(
+            instantiationService.createInstance(NotificationsAlerts, notificationService.model)
+        );
         const notificationsStatus = instantiationService.createInstance(NotificationsStatus, notificationService.model);
         this._register(notificationsCenter.onDidChangeVisibility(() => {
             notificationsStatus.update(notificationsCenter.isVisible, notificationsToasts.isVisible);
@@ -237,36 +327,37 @@ class Workbench extends Layout {
         registerNotificationCommands(notificationsCenter, notificationsToasts, notificationService.model);
         AccessibleViewRegistry.register(( new NotificationAccessibleView()));
         this.registerNotifications({
-            onDidChangeNotificationsVisibility: ( Event.map(
-                Event.any(notificationsToasts.onDidChangeVisibility, notificationsCenter.onDidChangeVisibility),
-                () => notificationsToasts.isVisible || notificationsCenter.isVisible
-            ))
+            onDidChangeNotificationsVisibility: ( Event.map(Event.any(
+                notificationsToasts.onDidChangeVisibility,
+                notificationsCenter.onDidChangeVisibility
+            ), () => notificationsToasts.isVisible || notificationsCenter.isVisible))
         });
     }
     restore(instantiationService, lifecycleService) {
         try {
             this.restoreParts(instantiationService);
-        }
-        catch (error) {
+        } catch (error) {
             onUnexpectedError(error);
         }
-        this.whenReady.finally(() => Promise.race([
-            this.whenRestored,
-            timeout(2000)
-        ]).finally(() => {
+        this.whenReady.finally(() => Promise.race([this.whenRestored, timeout(2000)]).finally(() => {
             function markDidStartWorkbench() {
-                mark('code/didStartWorkbench');
-                performance.measure('perf: workbench create & restore', 'code/didLoadWorkbenchMain', 'code/didStartWorkbench');
+                mark("code/didStartWorkbench");
+                performance.measure(
+                    "perf: workbench create & restore",
+                    "code/didLoadWorkbenchMain",
+                    "code/didStartWorkbench"
+                );
             }
             if (this.isRestored()) {
                 markDidStartWorkbench();
-            }
-            else {
+            } else {
                 this.whenRestored.finally(() => markDidStartWorkbench());
             }
             lifecycleService.phase = LifecyclePhase.Restored;
             const eventuallyPhaseScheduler = this._register(( new RunOnceScheduler(() => {
-                this._register(runWhenWindowIdle(mainWindow, () => lifecycleService.phase = LifecyclePhase.Eventually, 2500));
+                this._register(
+                    runWhenWindowIdle(mainWindow, () => lifecycleService.phase = LifecyclePhase.Eventually, 2500)
+                );
             }, 2500)));
             eventuallyPhaseScheduler.schedule();
         }));