@codingame/monaco-vscode-api 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibilityStatus.js

@@ -0,0 +1,112 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { Event } from '../../../../base/common/event.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { NotificationPriority, INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+let AccessibilityStatus = class AccessibilityStatus extends Disposable {
+    static { this.ID = 'workbench.contrib.accessibilityStatus'; }
+    constructor(configurationService, notificationService, accessibilityService, statusbarService) {
+        super();
+        this.configurationService = configurationService;
+        this.notificationService = notificationService;
+        this.accessibilityService = accessibilityService;
+        this.statusbarService = statusbarService;
+        this.screenReaderNotification = null;
+        this.promptedScreenReader = false;
+        this.screenReaderModeElement = this._register(( new MutableDisposable()));
+        this._register(CommandsRegistry.registerCommand({ id: 'showEditorScreenReaderNotification', handler: () => this.showScreenReaderNotification() }));
+        this.updateScreenReaderModeElement(this.accessibilityService.isScreenReaderOptimized());
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => this.onScreenReaderModeChange()));
+        this._register(this.configurationService.onDidChangeConfiguration(c => {
+            if (c.affectsConfiguration('editor.accessibilitySupport')) {
+                this.onScreenReaderModeChange();
+            }
+        }));
+    }
+    showScreenReaderNotification() {
+        this.screenReaderNotification = this.notificationService.prompt(Severity$1.Info, ( localizeWithPath(
+            'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+            'screenReaderDetectedExplanation.question',
+            "Are you using a screen reader to operate VS Code?"
+        )), [{
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                    'screenReaderDetectedExplanation.answerYes',
+                    "Yes"
+                )),
+                run: () => {
+                    this.configurationService.updateValue('editor.accessibilitySupport', 'on', 2 );
+                }
+            }, {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                    'screenReaderDetectedExplanation.answerNo',
+                    "No"
+                )),
+                run: () => {
+                    this.configurationService.updateValue('editor.accessibilitySupport', 'off', 2 );
+                }
+            }], {
+            sticky: true,
+            priority: NotificationPriority.URGENT
+        });
+        Event.once(this.screenReaderNotification.onDidClose)(() => this.screenReaderNotification = null);
+    }
+    updateScreenReaderModeElement(visible) {
+        if (visible) {
+            if (!this.screenReaderModeElement.value) {
+                const text = ( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                    'screenReaderDetected',
+                    "Screen Reader Optimized"
+                ));
+                this.screenReaderModeElement.value = this.statusbarService.addEntry({
+                    name: ( localizeWithPath(
+                        'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                        'status.editor.screenReaderMode',
+                        "Screen Reader Mode"
+                    )),
+                    text,
+                    ariaLabel: text,
+                    command: 'showEditorScreenReaderNotification',
+                    kind: 'prominent',
+                    showInAllWindows: true
+                }, 'status.editor.screenReaderMode', 1 , 100.6);
+            }
+        }
+        else {
+            this.screenReaderModeElement.clear();
+        }
+    }
+    onScreenReaderModeChange() {
+        const screenReaderDetected = this.accessibilityService.isScreenReaderOptimized();
+        if (screenReaderDetected) {
+            const screenReaderConfiguration = this.configurationService.getValue('editor.accessibilitySupport');
+            if (screenReaderConfiguration === 'auto') {
+                if (!this.promptedScreenReader) {
+                    this.promptedScreenReader = true;
+                    setTimeout(() => this.showScreenReaderNotification(), 100);
+                }
+            }
+        }
+        if (this.screenReaderNotification) {
+            this.screenReaderNotification.close();
+        }
+        this.updateScreenReaderModeElement(this.accessibilityService.isScreenReaderOptimized());
+    }
+};
+AccessibilityStatus = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, INotificationService)),
+    ( __param(2, IAccessibilityService)),
+    ( __param(3, IStatusbarService))
+], AccessibilityStatus));
+export { AccessibilityStatus };

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibleView.js

@@ -5,11 +5,11 @@ import { alert } from '../../../../base/browser/ui/aria/aria.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import marked_1 from '../../../../../../../external/vscode-marked/lib/marked.esm.js';
-import { isMacintosh } from '../../../../base/common/platform.js';
+import { isWindows, isMacintosh } from '../../../../base/common/platform.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { URI } from '../../../../base/common/uri.js';
 import { EditorExtensionsRegistry } from '../../../../editor/browser/editorExtensions.js';
-import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditorWidget.js';
+import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
 import { Position } from '../../../../editor/common/core/position.js';
 import { IModelService } from '../../../../editor/common/services/model.js';
 import { AccessibilityHelpNLS } from '../../../../editor/common/standaloneStrings.js';
@@ -19,6 +19,7 @@ import { IAccessibilityService } from '../../../../platform/accessibility/common
 import { createAndFillInActionBarActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
 import { WorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
 import { MenuId, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
@@ -27,12 +28,13 @@ import { IKeybindingService } from '../../../../platform/keybinding/common/keybi
 import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { accessibilityHelpIsShown, accessibleViewIsShown, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, accessibleViewGoToSymbolSupported, accessibleViewCurrentProviderId, accessibleViewOnLastLine } from './accessibilityConfiguration.js';
+import { accessibilityHelpIsShown, accessibleViewIsShown, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, accessibleViewGoToSymbolSupported, accessibleViewCurrentProviderId, accessibleViewInCodeBlock, accessibleViewContainsCodeBlocks, accessibleViewOnLastLine } from './accessibilityConfiguration.js';
+import { IChatCodeBlockContextProviderService } from '../../chat/browser/chat.js';
 import { getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
 const IAccessibleViewService = ( createDecorator('accessibleViewService'));
 let AccessibleView = class AccessibleView extends Disposable {
     get editorWidget() { return this._editorWidget; }
-    constructor(_openerService, _instantiationService, _configurationService, _modelService, _contextViewService, _contextKeyService, _accessibilityService, _keybindingService, _layoutService, _menuService) {
+    constructor(_openerService, _instantiationService, _configurationService, _modelService, _contextViewService, _contextKeyService, _accessibilityService, _keybindingService, _layoutService, _menuService, _commandService, _codeBlockContextProviderService) {
         super();
         this._openerService = _openerService;
         this._instantiationService = _instantiationService;
@@ -44,12 +46,16 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._keybindingService = _keybindingService;
         this._layoutService = _layoutService;
         this._menuService = _menuService;
+        this._commandService = _commandService;
+        this._codeBlockContextProviderService = _codeBlockContextProviderService;
         this._accessiblityHelpIsShown = accessibilityHelpIsShown.bindTo(this._contextKeyService);
         this._accessibleViewIsShown = accessibleViewIsShown.bindTo(this._contextKeyService);
         this._accessibleViewSupportsNavigation = accessibleViewSupportsNavigation.bindTo(this._contextKeyService);
         this._accessibleViewVerbosityEnabled = accessibleViewVerbosityEnabled.bindTo(this._contextKeyService);
         this._accessibleViewGoToSymbolSupported = accessibleViewGoToSymbolSupported.bindTo(this._contextKeyService);
         this._accessibleViewCurrentProviderId = accessibleViewCurrentProviderId.bindTo(this._contextKeyService);
+        this._accessibleViewInCodeBlock = accessibleViewInCodeBlock.bindTo(this._contextKeyService);
+        this._accessibleViewContainsCodeBlocks = accessibleViewContainsCodeBlocks.bindTo(this._contextKeyService);
         this._onLastLine = accessibleViewOnLastLine.bindTo(this._contextKeyService);
         this._container = document.createElement('div');
         this._container.classList.add('accessible-view');
@@ -108,6 +114,13 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._register(this._editorWidget.onDidChangeCursorPosition(() => {
             this._onLastLine.set(this._editorWidget.getPosition()?.lineNumber === this._editorWidget.getModel()?.getLineCount());
         }));
+        this._register(this._editorWidget.onDidChangeCursorPosition(() => {
+            const cursorPosition = this._editorWidget.getPosition()?.lineNumber;
+            if (this._codeBlocks && cursorPosition !== undefined) {
+                const inCodeBlock = this._codeBlocks.find(c => c.startLine <= cursorPosition && c.endLine >= cursorPosition) !== undefined;
+                this._accessibleViewInCodeBlock.set(inCodeBlock);
+            }
+        }));
     }
     _resetContextKeys() {
         this._accessiblityHelpIsShown.reset();
@@ -129,6 +142,18 @@ let AccessibleView = class AccessibleView extends Disposable {
             this._editorWidget.revealPosition(position);
         }
     }
+    getCodeBlockContext() {
+        const position = this._editorWidget.getPosition();
+        if (!this._codeBlocks?.length || !position) {
+            return;
+        }
+        const codeBlockIndex = this._codeBlocks?.findIndex(c => c.startLine <= position?.lineNumber && c.endLine >= position?.lineNumber);
+        const codeBlock = codeBlockIndex !== undefined && codeBlockIndex > -1 ? this._codeBlocks[codeBlockIndex] : undefined;
+        if (!codeBlock || codeBlockIndex === undefined) {
+            return;
+        }
+        return { code: codeBlock.code, languageId: codeBlock.languageId, codeBlockIndex, element: undefined };
+    }
     showLastProvider(id) {
         if (!this._lastProvider || this._lastProvider.options.id !== id) {
             return;
@@ -174,6 +199,9 @@ let AccessibleView = class AccessibleView extends Disposable {
         if (provider.options.id) {
             this._lastProvider = provider;
         }
+        if (provider.id === "panelChat" ) {
+            this._register(this._codeBlockContextProviderService.registerProvider({ getCodeBlockContext: () => this.getCodeBlockContext() }, 'accessibleView'));
+        }
     }
     previous() {
         if (!this._currentProvider) {
@@ -193,6 +221,33 @@ let AccessibleView = class AccessibleView extends Disposable {
         }
         this._instantiationService.createInstance(AccessibleViewSymbolQuickPick, this).show(this._currentProvider);
     }
+    calculateCodeBlocks(markdown) {
+        if (this._currentProvider?.id !== "panelChat" ) {
+            return;
+        }
+        if (this._currentProvider.options.language && this._currentProvider.options.language !== 'markdown') {
+            return;
+        }
+        const lines = markdown.split('\n');
+        this._codeBlocks = [];
+        let inBlock = false;
+        let startLine = 0;
+        let languageId;
+        lines.forEach((line, i) => {
+            if (!inBlock && line.startsWith('```')) {
+                inBlock = true;
+                startLine = i + 1;
+                languageId = line.substring(3).trim();
+            }
+            else if (inBlock && line.startsWith('```')) {
+                inBlock = false;
+                const endLine = i;
+                const code = lines.slice(startLine, endLine).join('\n');
+                this._codeBlocks?.push({ startLine, endLine, code, languageId });
+            }
+        });
+        this._accessibleViewContainsCodeBlocks.set(this._codeBlocks.length > 0);
+    }
     getSymbols() {
         if (!this._currentProvider || !this._currentContent) {
             return;
@@ -304,10 +359,8 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._accessibleViewGoToSymbolSupported.set(this._goToSymbolsSupported() ? this.getSymbols()?.length > 0 : false);
     }
     _render(provider, container, showAccessibleViewHelp) {
-        if (!showAccessibleViewHelp) {
-            this._currentProvider = provider;
-            this._accessibleViewCurrentProviderId.set(provider.id);
-        }
+        this._currentProvider = provider;
+        this._accessibleViewCurrentProviderId.set(provider.id);
         const value = this._configurationService.getValue(provider.verbositySettingKey);
         const readMoreLink = provider.options.readMoreUrl ? ( localizeWithPath(
             'vs/workbench/contrib/accessibility/browser/accessibleView',
@@ -339,8 +392,11 @@ let AccessibleView = class AccessibleView extends Disposable {
             'exit',
             '\n\nExit this dialog (Escape).'
         )) : '';
-        this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint + exitThisDialogHint;
+        const newContent = message + provider.provideContent() + readMoreLink + disableHelpHint + exitThisDialogHint;
+        this.calculateCodeBlocks(newContent);
+        this._currentContent = newContent;
         this._updateContextKeys(provider, true);
+        const widgetIsFocused = this._editorWidget.hasTextFocus() || this._editorWidget.hasWidgetFocus();
         this._getTextModel(( URI.from(
             { path: `accessible-view-${provider.verbositySettingKey}`, scheme: 'accessible-view', fragment: this._currentContent }
         ))).then((model) => {
@@ -394,6 +450,9 @@ let AccessibleView = class AccessibleView extends Disposable {
                     actionsHint
                 ));
             }
+            if (isWindows && widgetIsFocused) {
+                ariaLabel = '';
+            }
             this._editorWidget.updateOptions({ ariaLabel });
             this._editorWidget.focus();
             if (this._currentProvider?.options.position) {
@@ -416,10 +475,14 @@ let AccessibleView = class AccessibleView extends Disposable {
             this._contextViewService.hideContextView();
             this._updateContextKeys(provider, false);
             this._lastProvider = undefined;
+            this._currentContent = undefined;
         };
         const disposableStore = ( new DisposableStore());
         disposableStore.add(this._editorWidget.onKeyDown((e) => {
-            if (e.keyCode === 9  || shouldHide(e.browserEvent, this._keybindingService, this._configurationService)) {
+            if (e.keyCode === 3 ) {
+                this._commandService.executeCommand('editor.action.openLink');
+            }
+            else if (e.keyCode === 9  || shouldHide(e.browserEvent, this._keybindingService, this._configurationService)) {
                 hide(e);
             }
             else if (e.keyCode === 38  && provider.options.readMoreUrl) {
@@ -521,8 +584,9 @@ let AccessibleView = class AccessibleView extends Disposable {
         const toolbarHint = ( localizeWithPath(
             'vs/workbench/contrib/accessibility/browser/accessibleView',
             'toolbar',
-            "Navigate to the toolbar (Shift+Tab))."
+            "Navigate to the toolbar (Shift+Tab)."
         ));
+        const chatHints = this._getChatHints();
         let hint = ( localizeWithPath(
             'vs/workbench/contrib/accessibility/browser/accessibleView',
             'intro',
@@ -537,6 +601,64 @@ let AccessibleView = class AccessibleView extends Disposable {
         if (toolbarHint) {
             hint += ' - ' + toolbarHint + '\n';
         }
+        if (chatHints) {
+            hint += chatHints;
+        }
+        return hint;
+    }
+    _getChatHints() {
+        if (this._currentProvider?.id !== "panelChat" ) {
+            return;
+        }
+        let hint = '';
+        const insertAtCursorKb = this._keybindingService.lookupKeybinding('workbench.action.chat.insertCodeBlock')?.getAriaLabel();
+        const insertIntoNewFileKb = this._keybindingService.lookupKeybinding('workbench.action.chat.insertIntoNewFile')?.getAriaLabel();
+        const runInTerminalKb = this._keybindingService.lookupKeybinding('workbench.action.chat.runInTerminal')?.getAriaLabel();
+        if (insertAtCursorKb) {
+            hint += ( localizeWithPath(
+                'vs/workbench/contrib/accessibility/browser/accessibleView',
+                'insertAtCursor',
+                " - Insert the code block at the cursor ({0}).\n",
+                insertAtCursorKb
+            ));
+        }
+        else {
+            hint += ( localizeWithPath(
+                'vs/workbench/contrib/accessibility/browser/accessibleView',
+                'insertAtCursorNoKb',
+                " - Insert the code block at the cursor by configuring a keybinding for the Chat: Insert Code Block command.\n"
+            ));
+        }
+        if (insertIntoNewFileKb) {
+            hint += ( localizeWithPath(
+                'vs/workbench/contrib/accessibility/browser/accessibleView',
+                'insertIntoNewFile',
+                " - Insert the code block into a new file ({0}).\n",
+                insertIntoNewFileKb
+            ));
+        }
+        else {
+            hint += ( localizeWithPath(
+                'vs/workbench/contrib/accessibility/browser/accessibleView',
+                'insertIntoNewFileNoKb',
+                " - Insert the code block into a new file by configuring a keybinding for the Chat: Insert into New File command.\n"
+            ));
+        }
+        if (runInTerminalKb) {
+            hint += ( localizeWithPath(
+                'vs/workbench/contrib/accessibility/browser/accessibleView',
+                'runInTerminal',
+                " - Run the code block in the terminal ({0}).\n",
+                runInTerminalKb
+            ));
+        }
+        else {
+            hint += ( localizeWithPath(
+                'vs/workbench/contrib/accessibility/browser/accessibleView',
+                'runInTerminalNoKb',
+                " - Run the coe block in the terminal by configuring a keybinding for the Chat: Insert into Terminal command.\n"
+            ));
+        }
         return hint;
     }
     _getNavigationHint() {
@@ -592,7 +714,7 @@ let AccessibleView = class AccessibleView extends Disposable {
                 goToSymbolHint = ( localizeWithPath(
                     'vs/workbench/contrib/accessibility/browser/accessibleView',
                     'goToSymbolHint',
-                    'Go to a symbol ({0})',
+                    'Go to a symbol ({0}).',
                     goToSymbolKb
                 ));
             }
@@ -617,7 +739,9 @@ AccessibleView = ( __decorate([
     ( __param(6, IAccessibilityService)),
     ( __param(7, IKeybindingService)),
     ( __param(8, ILayoutService)),
-    ( __param(9, IMenuService))
+    ( __param(9, IMenuService)),
+    ( __param(10, ICommandService)),
+    ( __param(11, IChatCodeBlockContextProviderService))
 ], AccessibleView));
 let AccessibleViewService = class AccessibleViewService extends Disposable {
     constructor(_instantiationService, _configurationService, _keybindingService) {
@@ -687,6 +811,9 @@ let AccessibleViewService = class AccessibleViewService extends Disposable {
             editorWidget?.revealLine(position.lineNumber);
         }
     }
+    getCodeBlockContext() {
+        return this._accessibleView?.getCodeBlockContext();
+    }
 };
 AccessibleViewService = ( __decorate([
     ( __param(0, IInstantiationService)),

package/vscode/src/vs/workbench/contrib/accessibility/browser/editorAccessibilityHelp.js

@@ -76,7 +76,7 @@ let EditorAccessibilityHelpProvider = class EditorAccessibilityHelpProvider {
         if (options.get(115 ).enabled) {
             content.push(descriptionForCommand('editor.action.focusStickyScroll', AccessibilityHelpNLS.stickScrollKb, AccessibilityHelpNLS.stickScrollNoKb, this._keybindingService));
         }
-        if (options.get(143 )) {
+        if (options.get(144 )) {
             content.push(descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOnMsg, AccessibilityHelpNLS.tabFocusModeOnMsgNoKb, this._keybindingService));
         }
         else {

package/vscode/src/vs/workbench/contrib/accessibility/browser/openDiffEditorAnnouncement.js

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isDiffEditor } from '../../../../editor/browser/editorBrowser.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { Event } from '../../../../base/common/event.js';
+let DiffEditorActiveAnnouncementContribution = class DiffEditorActiveAnnouncementContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.diffEditorActiveAnnouncement'; }
+    constructor(_editorService, _accessibilityService, _configurationService) {
+        super();
+        this._editorService = _editorService;
+        this._accessibilityService = _accessibilityService;
+        this._configurationService = _configurationService;
+        this._register(Event.runAndSubscribe(_accessibilityService.onDidChangeScreenReaderOptimized, () => this._updateListener()));
+        this._register(_configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("accessibility.verbosity.diffEditorActive" )) {
+                this._updateListener();
+            }
+        }));
+    }
+    _updateListener() {
+        const announcementEnabled = this._configurationService.getValue("accessibility.verbosity.diffEditorActive" );
+        const screenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+        if (!announcementEnabled || !screenReaderOptimized) {
+            this._onDidActiveEditorChangeListener?.dispose();
+            this._onDidActiveEditorChangeListener = undefined;
+            return;
+        }
+        if (this._onDidActiveEditorChangeListener) {
+            return;
+        }
+        this._onDidActiveEditorChangeListener = this._register(this._editorService.onDidActiveEditorChange(() => {
+            if (isDiffEditor(this._editorService.activeTextEditorControl)) {
+                this._accessibilityService.alert(( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/openDiffEditorAnnouncement',
+                    'openDiffEditorAnnouncement',
+                    "Diff editor"
+                )));
+            }
+        }));
+    }
+};
+DiffEditorActiveAnnouncementContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IAccessibilityService)),
+    ( __param(2, IConfigurationService))
+], DiffEditorActiveAnnouncementContribution));
+export { DiffEditorActiveAnnouncementContribution };

package/vscode/src/vs/workbench/contrib/accessibility/browser/saveAccessibilitySignal.js

@@ -0,0 +1,18 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.js';
+let SaveAccessibilitySignalContribution = class SaveAccessibilitySignalContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.saveAccessibilitySignal'; }
+    constructor(_accessibilitySignalService, _workingCopyService) {
+        super();
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._workingCopyService = _workingCopyService;
+        this._register(this._workingCopyService.onDidSave(e => this._accessibilitySignalService.playSignal(AccessibilitySignal.save, { userGesture: e.reason === 1  })));
+    }
+};
+SaveAccessibilitySignalContribution = ( __decorate([
+    ( __param(0, IAccessibilitySignalService)),
+    ( __param(1, IWorkingCopyService))
+], SaveAccessibilitySignalContribution));
+export { SaveAccessibilitySignalContribution };

package/vscode/src/vs/workbench/contrib/accessibility/browser/unfocusedViewDimmingContribution.js

@@ -0,0 +1,66 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createStyleSheet } from '../../../../base/browser/dom.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { clamp } from '../../../../base/common/numbers.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+let UnfocusedViewDimmingContribution = class UnfocusedViewDimmingContribution extends Disposable {
+    constructor(configurationService) {
+        super();
+        this._styleElementDisposables = undefined;
+        this._register(toDisposable(() => this._removeStyleElement()));
+        this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
+            if (e && !e.affectsConfiguration("accessibility.dimUnfocused.enabled" ) && !e.affectsConfiguration("accessibility.dimUnfocused.opacity" )) {
+                return;
+            }
+            let cssTextContent = '';
+            const enabled = ensureBoolean(configurationService.getValue("accessibility.dimUnfocused.enabled" ), false);
+            if (enabled) {
+                const opacity = clamp(ensureNumber(configurationService.getValue("accessibility.dimUnfocused.opacity" ), 0.75 ), 0.2 , 1 );
+                if (opacity !== 1) {
+                    const rules = ( new Set());
+                    const filterRule = `filter: opacity(${opacity});`;
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal:not(:focus-within) .tabs-container { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal .terminal-wrapper:not(:focus-within) { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .breadcrumbs-below-tabs { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .terminal-wrapper { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .settings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .keybindings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor-pane-placeholder { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .gettingStartedContainer { ${filterRule} }`);
+                    cssTextContent = [...rules].join('\n');
+                }
+            }
+            if (cssTextContent.length === 0) {
+                this._removeStyleElement();
+            }
+            else {
+                this._getStyleElement().textContent = cssTextContent;
+            }
+        }));
+    }
+    _getStyleElement() {
+        if (!this._styleElement) {
+            this._styleElementDisposables = ( new DisposableStore());
+            this._styleElement = createStyleSheet(undefined, undefined, this._styleElementDisposables);
+            this._styleElement.className = 'accessibilityUnfocusedViewOpacity';
+        }
+        return this._styleElement;
+    }
+    _removeStyleElement() {
+        this._styleElementDisposables?.dispose();
+        this._styleElementDisposables = undefined;
+        this._styleElement = undefined;
+    }
+};
+UnfocusedViewDimmingContribution = ( __decorate([
+    ( __param(0, IConfigurationService))
+], UnfocusedViewDimmingContribution));
+function ensureBoolean(value, defaultValue) {
+    return typeof value === 'boolean' ? value : defaultValue;
+}
+function ensureNumber(value, defaultValue) {
+    return typeof value === 'number' ? value : defaultValue;
+}
+export { UnfocusedViewDimmingContribution };

package/vscode/src/vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution.js

@@ -4,6 +4,7 @@ import { registerAction2 } from '../../../../platform/actions/common/actions.js'
 import { Extensions as Extensions$1 } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
 import { Extensions } from '../../../common/contributions.js';
+import '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
 import { AccessibilitySignalLineDebuggerContribution } from './accessibilitySignalDebuggerContribution.js';
 import { SignalLineFeatureContribution } from './accessibilitySignalLineFeatureContribution.js';
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SignalLineFeatureContribution, 3 );

package/vscode/src/vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignalDebuggerContribution.js

@@ -1,9 +1,11 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/derived.js';
+import { autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
 import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
 import { IDebugService } from '../../debug/common/debug.js';
-import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
-import { autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
 let AccessibilitySignalLineDebuggerContribution = class AccessibilitySignalLineDebuggerContribution extends Disposable {
     constructor(debugService, accessibilitySignalService) {
         super();