@codingame/monaco-vscode-accessibility-service-override 2.0.3 → 2.1.0

package/accessibility.js

@@ -1,14 +1,11 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { IAccessibleViewService, AccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
-import { IAccessibleNotificationService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
-import { AccessibleNotificationService } from './vscode/src/vs/workbench/contrib/accessibility/browser/accessibleNotificationService.js';
 import './vscode/src/vs/workbench/contrib/accessibility/browser/accessibility.contribution.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/accessibility/accessibility.js';
 
 function getServiceOverride() {
     return {
-        [( IAccessibleViewService.toString())]: new SyncDescriptor(AccessibleViewService, [], true),
-        [( IAccessibleNotificationService.toString())]: new SyncDescriptor(AccessibleNotificationService, [], true)
+        [( IAccessibleViewService.toString())]: new SyncDescriptor(AccessibleViewService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-accessibility-service-override",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@2.0.3",
+    "vscode": "npm:@codingame/monaco-vscode-api@2.1.0",
     "vscode-marked": "npm:marked@=3.0.2"
   }
 }

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

@@ -1,11 +1,12 @@
-import { registerAccessibilityConfiguration } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { registerAccessibilityConfiguration, DynamicSpeechAccessibilityConfiguration } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { UnfocusedViewDimmingContribution } from './unfocusedViewDimmingContribution.js';
 import { HoverAccessibleViewContribution, NotificationAccessibleViewContribution, InlineCompletionsAccessibleViewContribution } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityContributions';
 import { AccessibilityStatus } from './accessibilityStatus.js';
-import { CommentsAccessibilityHelpContribution } from 'vscode/vscode/vs/workbench/contrib/comments/browser/comments.contribution';
 import { EditorAccessibilityHelpContribution } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/editorAccessibilityHelp';
+import { SaveAudioCueContribution } from './saveAudioCue.js';
+import { CommentsAccessibilityHelpContribution } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsAccessibility';
 
 registerAccessibilityConfiguration();
 const workbenchRegistry = ( Registry.as(Extensions.Workbench));
@@ -17,3 +18,5 @@ workbenchContributionsRegistry.registerWorkbenchContribution(HoverAccessibleView
 workbenchContributionsRegistry.registerWorkbenchContribution(NotificationAccessibleViewContribution, 4 );
 workbenchContributionsRegistry.registerWorkbenchContribution(InlineCompletionsAccessibleViewContribution, 4 );
 workbenchContributionsRegistry.registerWorkbenchContribution(AccessibilityStatus, 2 );
+workbenchContributionsRegistry.registerWorkbenchContribution(SaveAudioCueContribution, 2 );
+workbenchContributionsRegistry.registerWorkbenchContribution(DynamicSpeechAccessibilityConfiguration, 2 );

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable, toDisposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import Severity from 'vscode/vscode/vs/base/common/severity';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
@@ -8,25 +8,81 @@ import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/comm
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { NotificationPriority, INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
 import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 
+let ScreenReaderModeStatusEntry = class ScreenReaderModeStatusEntry extends Disposable {
+    constructor(statusbarService) {
+        super();
+        this.statusbarService = statusbarService;
+        this.screenReaderModeElement = this._register(( new MutableDisposable()));
+    }
+    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'
+                }, 'status.editor.screenReaderMode', 1 , 100.6);
+            }
+        }
+        else {
+            this.screenReaderModeElement.clear();
+        }
+    }
+};
+ScreenReaderModeStatusEntry = ( __decorate([
+    ( __param(0, IStatusbarService))
+], ScreenReaderModeStatusEntry));
 let AccessibilityStatus = class AccessibilityStatus extends Disposable {
-    constructor(configurationService, notificationService, _accessibilityService, statusbarService) {
+    constructor(configurationService, notificationService, accessibilityService, instantiationService, editorGroupService) {
         super();
         this.configurationService = configurationService;
         this.notificationService = notificationService;
-        this._accessibilityService = _accessibilityService;
-        this.statusbarService = statusbarService;
+        this.accessibilityService = accessibilityService;
+        this.editorGroupService = editorGroupService;
         this.screenReaderNotification = null;
         this.promptedScreenReader = false;
-        this.screenReaderModeElement = this._register(( new MutableDisposable()));
-        this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => this.onScreenReaderModeChange()));
-        this._register(configurationService.onDidChangeConfiguration(c => {
+        this.screenReaderModeElements = ( new Set());
+        this.createScreenReaderModeElement(instantiationService, this._store);
+        this.updateScreenReaderModeElements(accessibilityService.isScreenReaderOptimized());
+        CommandsRegistry.registerCommand({ id: 'showEditorScreenReaderNotification', handler: () => this.showScreenReaderNotification() });
+        this.registerListeners();
+    }
+    createScreenReaderModeElement(instantiationService, disposables) {
+        const entry = disposables.add(instantiationService.createInstance(ScreenReaderModeStatusEntry));
+        this.screenReaderModeElements.add(entry);
+        disposables.add(toDisposable(() => this.screenReaderModeElements.delete(entry)));
+        return entry;
+    }
+    updateScreenReaderModeElements(visible) {
+        for (const entry of this.screenReaderModeElements) {
+            entry.updateScreenReaderModeElement(visible);
+        }
+    }
+    registerListeners() {
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => this.onScreenReaderModeChange()));
+        this._register(this.configurationService.onDidChangeConfiguration(c => {
             if (c.affectsConfiguration('editor.accessibilitySupport')) {
                 this.onScreenReaderModeChange();
             }
         }));
-        CommandsRegistry.registerCommand({ id: 'showEditorScreenReaderNotification', handler: () => this.showScreenReaderNotification() });
-        this.updateScreenReaderModeElement(this._accessibilityService.isScreenReaderOptimized());
+        this._register(this.editorGroupService.onDidCreateAuxiliaryEditorPart(({ instantiationService, disposables }) => {
+            const entry = this.createScreenReaderModeElement(instantiationService, disposables);
+            entry.updateScreenReaderModeElement(this.accessibilityService.isScreenReaderOptimized());
+        }));
     }
     showScreenReaderNotification() {
         this.screenReaderNotification = this.notificationService.prompt(Severity.Info, ( localizeWithPath(
@@ -57,33 +113,8 @@ let AccessibilityStatus = class AccessibilityStatus extends Disposable {
         });
         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'
-                }, 'status.editor.screenReaderMode', 1 , 100.6);
-            }
-        }
-        else {
-            this.screenReaderModeElement.clear();
-        }
-    }
     onScreenReaderModeChange() {
-        const screenReaderDetected = this._accessibilityService.isScreenReaderOptimized();
+        const screenReaderDetected = this.accessibilityService.isScreenReaderOptimized();
         if (screenReaderDetected) {
             const screenReaderConfiguration = this.configurationService.getValue('editor.accessibilitySupport');
             if (screenReaderConfiguration === 'auto') {
@@ -96,14 +127,21 @@ let AccessibilityStatus = class AccessibilityStatus extends Disposable {
         if (this.screenReaderNotification) {
             this.screenReaderNotification.close();
         }
-        this.updateScreenReaderModeElement(this._accessibilityService.isScreenReaderOptimized());
+        this.updateScreenReaderModeElements(this.accessibilityService.isScreenReaderOptimized());
+    }
+    dispose() {
+        super.dispose();
+        for (const entry of this.screenReaderModeElements) {
+            entry.dispose();
+        }
     }
 };
 AccessibilityStatus = ( __decorate([
     ( __param(0, IConfigurationService)),
     ( __param(1, INotificationService)),
     ( __param(2, IAccessibilityService)),
-    ( __param(3, IStatusbarService))
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IEditorGroupsService))
 ], AccessibilityStatus));
 
 export { AccessibilityStatus };

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

@@ -0,0 +1,21 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { AudioCue, IAudioCueService } from 'vscode/vscode/vs/platform/audioCues/browser/audioCueService';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+
+let SaveAudioCueContribution = class SaveAudioCueContribution extends Disposable {
+    constructor(_audioCueService, _workingCopyService) {
+        super();
+        this._audioCueService = _audioCueService;
+        this._workingCopyService = _workingCopyService;
+        this._register(this._workingCopyService.onDidSave((e) => {
+            this._audioCueService.playAudioCue(AudioCue.save, { userGesture: e.reason === 1  });
+        }));
+    }
+};
+SaveAudioCueContribution = ( __decorate([
+    ( __param(0, IAudioCueService)),
+    ( __param(1, IWorkingCopyService))
+], SaveAudioCueContribution));
+
+export { SaveAudioCueContribution };

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

@@ -1,83 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
-import { AudioCue, IAudioCueService } from 'vscode/vscode/vs/platform/audioCues/browser/audioCueService';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
-
-let AccessibleNotificationService = class AccessibleNotificationService extends Disposable {
-    constructor(_audioCueService, _configurationService, _accessibilityService, _workingCopyService, _logService) {
-        super();
-        this._audioCueService = _audioCueService;
-        this._configurationService = _configurationService;
-        this._accessibilityService = _accessibilityService;
-        this._workingCopyService = _workingCopyService;
-        this._logService = _logService;
-        this._events = ( new Map());
-        this._events.set("clear" , { audioCue: AudioCue.clear, alertMessage: ( localizeWithPath(
-            'vs/workbench/contrib/accessibility/browser/accessibleNotificationService',
-            'cleared',
-            "Cleared"
-        )) });
-        this._events.set("save" , { audioCue: AudioCue.save, alertMessage: ( localizeWithPath(
-            'vs/workbench/contrib/accessibility/browser/accessibleNotificationService',
-            'saved',
-            "Saved"
-        )), alertSetting: "accessibility.alert.save"  });
-        this._events.set("format" , { audioCue: AudioCue.format, alertMessage: ( localizeWithPath(
-            'vs/workbench/contrib/accessibility/browser/accessibleNotificationService',
-            'formatted',
-            "Formatted"
-        )), alertSetting: "accessibility.alert.format"  });
-        this._register(this._workingCopyService.onDidSave((e) => this._notify("save" , e.reason === 1 )));
-    }
-    notify(event, userGesture) {
-        if (event === "format" ) {
-            return this._notify(event, userGesture);
-        }
-        const { audioCue, alertMessage } = this._events.get(event);
-        const audioCueValue = this._configurationService.getValue(audioCue.settingsKey);
-        if (audioCueValue === 'on' || audioCueValue === 'auto' && this._accessibilityService.isScreenReaderOptimized()) {
-            this._logService.debug('AccessibleNotificationService playing sound: ', audioCue.name);
-            this._audioCueService.playAudioCue(audioCue);
-        }
-        else {
-            this._logService.debug('AccessibleNotificationService alerting: ', alertMessage);
-            this._accessibilityService.alert(alertMessage);
-        }
-    }
-    _notify(event, userGesture) {
-        const { audioCue, alertMessage, alertSetting } = this._events.get(event);
-        if (!alertSetting) {
-            return;
-        }
-        const audioCueSetting = this._configurationService.getValue(audioCue.settingsKey);
-        if (this._shouldNotify(audioCueSetting, userGesture)) {
-            this._logService.debug('AccessibleNotificationService playing sound: ', audioCue.name);
-            this._audioCueService.playSound(audioCue.sound.getSound(), true);
-            return;
-        }
-        if (audioCueSetting !== 'never') {
-            return;
-        }
-        const alertSettingValue = this._configurationService.getValue(alertSetting);
-        if (this._shouldNotify(alertSettingValue, userGesture)) {
-            this._logService.debug('AccessibleNotificationService alerting: ', alertMessage);
-            this._accessibilityService.alert(alertMessage);
-        }
-    }
-    _shouldNotify(settingValue, userGesture) {
-        return settingValue === 'always' || settingValue === 'userGesture' && userGesture === true;
-    }
-};
-AccessibleNotificationService = ( __decorate([
-    ( __param(0, IAudioCueService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IAccessibilityService)),
-    ( __param(3, IWorkingCopyService)),
-    ( __param(4, ILogService))
-], AccessibleNotificationService));
-
-export { AccessibleNotificationService };