@codingame/monaco-vscode-api 4.5.2 → 5.0.0

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -1,16 +1,18 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CachedFunction } from '../../../base/common/cache.js';
+import { getStructuralKey } from '../../../base/common/equals.js';
 import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
 import { FileAccess } from '../../../base/common/network.js';
-import { IAccessibilityService } from '../../accessibility/common/accessibility.service.js';
-import { IConfigurationService } from '../../configuration/common/configuration.service.js';
-import { Event } from '../../../base/common/event.js';
-import { localizeWithPath } from '../../../nls.js';
 import { derived } from '../../../base/common/observableInternal/derived.js';
 import '../../../base/common/observableInternal/autorun.js';
-import { observableFromEvent } from '../../../base/common/observableInternal/utils.js';
+import { observableFromEvent, ValueWithChangeEventFromObservable } from '../../../base/common/observableInternal/utils.js';
 import '../../../base/common/cancellation.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IAccessibilityService } from '../../accessibility/common/accessibility.service.js';
+import { IConfigurationService } from '../../configuration/common/configuration.service.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
 const _moduleId = "vs/platform/accessibilitySignal/browser/accessibilitySignalService";
+const AcknowledgeDocCommentsToken = Symbol('AcknowledgeDocCommentsToken');
 let AccessibilitySignalService = class AccessibilitySignalService extends Disposable {
     constructor(configurationService, accessibilityService, telemetryService) {
         super();
@@ -21,43 +23,39 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
         this.screenReaderAttached = observableFromEvent(this.accessibilityService.onDidChangeScreenReaderOptimized, () =>  this.accessibilityService.isScreenReaderOptimized());
         this.sentTelemetry = ( (new Set()));
         this.playingSounds = ( (new Set()));
-        this.obsoleteAccessibilitySignalsEnabled = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration('accessibilitySignals.enabled')), () =>  this.configurationService.getValue('accessibilitySignals.enabled'));
-        this.isSoundEnabledCache = ( (new Cache((event) => {
-            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.signal.legacySoundSettingsKey) || e.affectsConfiguration(event.signal.settingsKey)), () => this.configurationService.getValue(event.signal.settingsKey + '.sound'));
+        this._signalConfigValue = ( (new CachedFunction(
+            (signal) => observableConfigValue(signal.settingsKey, this.configurationService)
+        )));
+        this._signalEnabledState = ( (new CachedFunction({ getCacheKey: getStructuralKey }, (arg) => {
             return derived(reader => {
-                const setting = settingObservable.read(reader);
-                if (setting === 'on' ||
-                    (setting === 'auto' && this.screenReaderAttached.read(reader))) {
-                    return true;
-                }
-                else if (setting === 'always' || setting === 'userGesture' && event.userGesture) {
-                    return true;
+                const setting = this._signalConfigValue.get(arg.signal).read(reader);
+                if (arg.modality === 'sound' || arg.modality === undefined) {
+                    if (checkEnabledState(setting.sound, () => this.screenReaderAttached.read(reader), arg.userGesture)) {
+                        return true;
+                    }
                 }
-                const obsoleteSetting = this.obsoleteAccessibilitySignalsEnabled.read(reader);
-                if (obsoleteSetting === 'on' ||
-                    (obsoleteSetting === 'auto' && this.screenReaderAttached.read(reader))) {
-                    return true;
+                if (arg.modality === 'announcement' || arg.modality === undefined) {
+                    if (checkEnabledState(setting.announcement, () => this.screenReaderAttached.read(reader), arg.userGesture)) {
+                        return true;
+                    }
                 }
                 return false;
-            });
-        }, JSON.stringify)));
-        this.isAnnouncementEnabledCache = ( (new Cache((event) => {
-            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.signal.legacyAnnouncementSettingsKey) || e.affectsConfiguration(event.signal.settingsKey)), () => event.signal.announcementMessage ? this.configurationService.getValue(event.signal.settingsKey + '.announcement') : false);
-            return derived(reader => {
-                const setting = settingObservable.read(reader);
-                if (!this.screenReaderAttached.read(reader)) {
-                    return false;
-                }
-                return setting === 'auto' || setting === 'always' || setting === 'userGesture' && event.userGesture;
-            });
-        }, JSON.stringify)));
+            }).recomputeInitiallyAndOnChange(this._store);
+        })));
+    }
+    getEnabledState(signal, userGesture, modality) {
+        return (
+             (new ValueWithChangeEventFromObservable(this._signalEnabledState.get({ signal, userGesture, modality })))
+        );
     }
     async playSignal(signal, options = {}) {
+        const shouldPlayAnnouncement = options.modality === 'announcement' || options.modality === undefined;
         const announcementMessage = signal.announcementMessage;
-        if (this.isAnnouncementEnabled(signal, options.userGesture) && announcementMessage) {
+        if (shouldPlayAnnouncement && this.isAnnouncementEnabled(signal, options.userGesture) && announcementMessage) {
             this.accessibilityService.status(announcementMessage);
         }
-        if (this.isSoundEnabled(signal, options.userGesture)) {
+        const shouldPlaySound = options.modality === 'sound' || options.modality === undefined;
+        if (shouldPlaySound && this.isSoundEnabled(signal, options.userGesture)) {
             this.sendSignalTelemetry(signal, options.source);
             await this.playSound(signal.sound.getSound(), options.allowManyInParallel);
         }
@@ -143,16 +141,13 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
         if (!signal.announcementMessage) {
             return false;
         }
-        return this.isAnnouncementEnabledCache.get({ signal, userGesture }).get() ?? false;
+        return this._signalEnabledState.get({ signal, userGesture: !!userGesture, modality: 'announcement' }).get();
     }
     isSoundEnabled(signal, userGesture) {
-        return this.isSoundEnabledCache.get({ signal, userGesture }).get() ?? false;
+        return this._signalEnabledState.get({ signal, userGesture: !!userGesture, modality: 'sound' }).get();
     }
     onSoundEnabledChanged(signal) {
-        return Event.fromObservableLight(this.isSoundEnabledCache.get({ signal }));
-    }
-    onAnnouncementEnabledChanged(signal) {
-        return Event.fromObservableLight(this.isAnnouncementEnabledCache.get({ signal }));
+        return this.getEnabledState(signal, false).onDidChange;
     }
 };
 AccessibilitySignalService = ( (__decorate([
@@ -160,6 +155,9 @@ AccessibilitySignalService = ( (__decorate([
     ( (__param(1, IAccessibilityService))),
     ( (__param(2, ITelemetryService)))
 ], AccessibilitySignalService)));
+function checkEnabledState(state, getScreenReaderAttached, isTriggeredByUserGesture) {
+    return state === 'on' || state === 'always' || (state === 'auto' && getScreenReaderAttached()) || state === 'userGesture' && isTriggeredByUserGesture;
+}
 function playAudio(url, volume) {
     return (
          (new Promise((resolve, reject) => {
@@ -177,22 +175,6 @@ function playAudio(url, volume) {
         }))
     );
 }
-class Cache {
-    constructor(getValue, getKey) {
-        this.getValue = getValue;
-        this.getKey = getKey;
-        this.map = ( (new Map()));
-    }
-    get(arg) {
-        if (( (this.map.has(arg)))) {
-            return this.map.get(arg);
-        }
-        const value = this.getValue(arg);
-        const key = this.getKey(arg);
-        this.map.set(key, value);
-        return value;
-    }
-}
 class Sound {
     static register(options) {
         const sound = ( (new Sound(options.fileName)));
@@ -210,7 +192,6 @@ class Sound {
     static { this.diffLineDeleted = Sound.register({ fileName: 'diffLineDeleted.mp3' }); }
     static { this.diffLineModified = Sound.register({ fileName: 'diffLineModified.mp3' }); }
     static { this.chatRequestSent = Sound.register({ fileName: 'chatRequestSent.mp3' }); }
-    static { this.chatResponsePending = Sound.register({ fileName: 'chatResponsePending.mp3' }); }
     static { this.chatResponseReceived1 = Sound.register({ fileName: 'chatResponseReceived1.mp3' }); }
     static { this.chatResponseReceived2 = Sound.register({ fileName: 'chatResponseReceived2.mp3' }); }
     static { this.chatResponseReceived3 = Sound.register({ fileName: 'chatResponseReceived3.mp3' }); }
@@ -220,6 +201,7 @@ class Sound {
     static { this.format = Sound.register({ fileName: 'format.mp3' }); }
     static { this.voiceRecordingStarted = Sound.register({ fileName: 'voiceRecordingStarted.mp3' }); }
     static { this.voiceRecordingStopped = Sound.register({ fileName: 'voiceRecordingStopped.mp3' }); }
+    static { this.progress = Sound.register({ fileName: 'progress.mp3' }); }
     constructor(fileName) {
         this.fileName = fileName;
     }
@@ -239,6 +221,14 @@ class SoundSource {
     }
 }
 class AccessibilitySignal {
+    constructor(sound, name, legacySoundSettingsKey, settingsKey, legacyAnnouncementSettingsKey, announcementMessage) {
+        this.sound = sound;
+        this.name = name;
+        this.legacySoundSettingsKey = legacySoundSettingsKey;
+        this.settingsKey = settingsKey;
+        this.legacyAnnouncementSettingsKey = legacyAnnouncementSettingsKey;
+        this.announcementMessage = announcementMessage;
+    }
     static { this._signals = ( (new Set())); }
     static register(options) {
         const soundSource = ( (new SoundSource(
@@ -258,144 +248,156 @@ class AccessibilitySignal {
     static get allAccessibilitySignals() {
         return [...this._signals];
     }
-    static { this.error = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 0, 'Error on Line')),
+    static { this.errorAtPosition = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 0, 'Error at Position')),
+        sound: Sound.error,
+        announcementMessage: ( localizeWithPath(_moduleId, 1, 'Error')),
+        settingsKey: 'accessibility.signals.positionHasError',
+    }); }
+    static { this.warningAtPosition = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 2, 'Warning at Position')),
+        sound: Sound.warning,
+        announcementMessage: ( localizeWithPath(_moduleId, 3, 'Warning')),
+        settingsKey: 'accessibility.signals.positionHasWarning',
+    }); }
+    static { this.errorOnLine = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 4, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: "accessibility.alert.error" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 1, 'Error')),
-        settingsKey: 'accessibility.signals.lineHasError'
+        announcementMessage: ( localizeWithPath(_moduleId, 5, 'Error on Line')),
+        settingsKey: 'accessibility.signals.lineHasError',
     }); }
-    static { this.warning = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 2, 'Warning on Line')),
+    static { this.warningOnLine = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 6, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: "accessibility.alert.warning" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 3, 'Warning')),
-        settingsKey: 'accessibility.signals.lineHasWarning'
+        announcementMessage: ( localizeWithPath(_moduleId, 7, 'Warning on Line')),
+        settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 4, 'Folded Area on Line')),
+        name: ( localizeWithPath(_moduleId, 8, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: "accessibility.alert.foldedArea" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 5, 'Folded')),
-        settingsKey: 'accessibility.signals.lineHasFoldedArea'
+        announcementMessage: ( localizeWithPath(_moduleId, 9, 'Folded')),
+        settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 6, 'Breakpoint on Line')),
+        name: ( localizeWithPath(_moduleId, 10, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: "accessibility.alert.breakpoint" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 7, 'Breakpoint')),
-        settingsKey: 'accessibility.signals.lineHasBreakpoint'
+        announcementMessage: ( localizeWithPath(_moduleId, 11, 'Breakpoint')),
+        settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 8, 'Inline Suggestion on Line')),
+        name: ( localizeWithPath(_moduleId, 12, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
-        settingsKey: 'accessibility.signals.lineHasInlineSuggestion'
+        settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 9, 'Terminal Quick Fix')),
+        name: ( localizeWithPath(_moduleId, 13, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: "accessibility.alert.terminalQuickFix" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 10, 'Quick Fix')),
-        settingsKey: 'accessibility.signals.terminalQuickFix'
+        announcementMessage: ( localizeWithPath(_moduleId, 14, 'Quick Fix')),
+        settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 11, 'Debugger Stopped on Breakpoint')),
+        name: ( localizeWithPath(_moduleId, 15, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: "accessibility.alert.onDebugBreak" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 12, 'Breakpoint')),
-        settingsKey: 'accessibility.signals.onDebugBreak'
+        announcementMessage: ( localizeWithPath(_moduleId, 16, 'Breakpoint')),
+        settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 13, 'No Inlay Hints on Line')),
+        name: ( localizeWithPath(_moduleId, 17, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: "accessibility.alert.noInlayHints" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 14, 'No Inlay Hints')),
-        settingsKey: 'accessibility.signals.noInlayHints'
+        announcementMessage: ( localizeWithPath(_moduleId, 18, 'No Inlay Hints')),
+        settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 15, 'Task Completed')),
+        name: ( localizeWithPath(_moduleId, 19, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: "accessibility.alert.taskCompleted" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 16, 'Task Completed')),
-        settingsKey: 'accessibility.signals.taskCompleted'
+        announcementMessage: ( localizeWithPath(_moduleId, 20, 'Task Completed')),
+        settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 17, 'Task Failed')),
+        name: ( localizeWithPath(_moduleId, 21, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: "accessibility.alert.taskFailed" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 18, 'Task Failed')),
-        settingsKey: 'accessibility.signals.taskFailed'
+        announcementMessage: ( localizeWithPath(_moduleId, 22, 'Task Failed')),
+        settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 19, 'Terminal Command Failed')),
+        name: ( localizeWithPath(_moduleId, 23, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: "accessibility.alert.terminalCommandFailed" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 20, 'Command Failed')),
-        settingsKey: 'accessibility.signals.terminalCommandFailed'
+        announcementMessage: ( localizeWithPath(_moduleId, 24, 'Command Failed')),
+        settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 21, 'Terminal Bell')),
+        name: ( localizeWithPath(_moduleId, 25, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: "accessibility.alert.terminalBell" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 22, 'Terminal Bell')),
-        settingsKey: 'accessibility.signals.terminalBell'
+        announcementMessage: ( localizeWithPath(_moduleId, 26, 'Terminal Bell')),
+        settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 23, 'Notebook Cell Completed')),
+        name: ( localizeWithPath(_moduleId, 27, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellCompleted" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 24, 'Notebook Cell Completed')),
-        settingsKey: 'accessibility.signals.notebookCellCompleted'
+        announcementMessage: ( localizeWithPath(_moduleId, 28, 'Notebook Cell Completed')),
+        settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 25, 'Notebook Cell Failed')),
+        name: ( localizeWithPath(_moduleId, 29, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellFailed" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 26, 'Notebook Cell Failed')),
-        settingsKey: 'accessibility.signals.notebookCellFailed'
+        announcementMessage: ( localizeWithPath(_moduleId, 30, 'Notebook Cell Failed')),
+        settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 27, 'Diff Line Inserted')),
+        name: ( localizeWithPath(_moduleId, 31, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
-        settingsKey: 'accessibility.signals.diffLineInserted'
+        settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 28, 'Diff Line Deleted')),
+        name: ( localizeWithPath(_moduleId, 32, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
-        settingsKey: 'accessibility.signals.diffLineDeleted'
+        settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 29, 'Diff Line Modified')),
+        name: ( localizeWithPath(_moduleId, 33, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
-        settingsKey: 'accessibility.signals.diffLineModified'
+        settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 30, 'Chat Request Sent')),
+        name: ( localizeWithPath(_moduleId, 34, 'Chat Request Sent')),
         sound: Sound.chatRequestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: "accessibility.alert.chatRequestSent" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 31, 'Chat Request Sent')),
-        settingsKey: 'accessibility.signals.chatRequestSent'
+        announcementMessage: ( localizeWithPath(_moduleId, 35, 'Chat Request Sent')),
+        settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 32, 'Chat Response Received')),
+        name: ( localizeWithPath(_moduleId, 36, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -407,57 +409,56 @@ class AccessibilitySignal {
         },
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
-    static { this.chatResponsePending = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 33, 'Chat Response Pending')),
-        sound: Sound.chatResponsePending,
+    static { this.progress = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 37, 'Progress')),
+        sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
-        legacyAnnouncementSettingsKey: "accessibility.alert.chatResponsePending" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 34, 'Chat Response Pending')),
-        settingsKey: 'accessibility.signals.chatResponsePending'
+        legacyAnnouncementSettingsKey: "accessibility.alert.chatResponseProgress" ,
+        announcementMessage: ( localizeWithPath(_moduleId, 38, 'Progress')),
+        settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 35, 'Clear')),
+        name: ( localizeWithPath(_moduleId, 39, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: "accessibility.alert.clear" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 36, 'Clear')),
+        announcementMessage: ( localizeWithPath(_moduleId, 40, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 37, 'Save')),
+        name: ( localizeWithPath(_moduleId, 41, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: "accessibility.alert.save" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 38, 'Save')),
+        announcementMessage: ( localizeWithPath(_moduleId, 42, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 39, 'Format')),
+        name: ( localizeWithPath(_moduleId, 43, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: "accessibility.alert.format" ,
-        announcementMessage: ( localizeWithPath(_moduleId, 40, 'Format')),
+        announcementMessage: ( localizeWithPath(_moduleId, 44, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 41, 'Voice Recording Started')),
+        name: ( localizeWithPath(_moduleId, 45, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localizeWithPath(_moduleId, 42, 'Voice Recording Stopped')),
+        name: ( localizeWithPath(_moduleId, 46, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
-    constructor(sound, name, legacySoundSettingsKey, settingsKey, legacyAnnouncementSettingsKey, announcementMessage) {
-        this.sound = sound;
-        this.name = name;
-        this.legacySoundSettingsKey = legacySoundSettingsKey;
-        this.settingsKey = settingsKey;
-        this.legacyAnnouncementSettingsKey = legacyAnnouncementSettingsKey;
-        this.announcementMessage = announcementMessage;
-    }
 }
-export { AccessibilitySignal, AccessibilitySignalService, Sound, SoundSource };
+function observableConfigValue(key, configurationService) {
+    return observableFromEvent((handleChange) => configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(key)) {
+            handleChange(e);
+        }
+    }), () => configurationService.getValue(key));
+}
+export { AccessibilitySignal, AccessibilitySignalService, AcknowledgeDocCommentsToken, Sound, SoundSource, observableConfigValue };

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service.d.ts

@@ -1,7 +1,7 @@
 import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { IValueWithChangeEvent, Event } from '../../../base/common/event.js';
 import { IDisposable } from '../../../base/common/lifecycle.js';
-import { Event } from '../../../base/common/event.js';
-import { AccessibilitySignal, IAccessbilitySignalOptions, Sound } from './accessibilitySignalService.js';
+import { AccessibilitySignal, IAccessbilitySignalOptions, AccessibilityModality, Sound, AcknowledgeDocCommentsToken } from './accessibilitySignalService.js';
 
 declare const IAccessibilitySignalService: ServiceIdentifier<IAccessibilitySignalService>;
 interface IAccessibilitySignalService {
@@ -11,12 +11,19 @@ interface IAccessibilitySignalService {
         signal: AccessibilitySignal;
         source: string;
     })[]): Promise<void>;
+    playSignalLoop(signal: AccessibilitySignal, milliseconds: number): IDisposable;
+    getEnabledState(signal: AccessibilitySignal, userGesture: boolean, modality?: AccessibilityModality | undefined): IValueWithChangeEvent<boolean>;
+    /**
+    * Avoid this method and prefer `.playSignal`!
+    * Only use it when you want to play the sound regardless of enablement, e.g. in the settings quick pick.
+    */
+    playSound(signal: Sound, allowManyInParallel: boolean, token: typeof AcknowledgeDocCommentsToken): Promise<void>;
+    /** @deprecated Use getEnabledState(...).onChange */
     isSoundEnabled(signal: AccessibilitySignal): boolean;
+    /** @deprecated Use getEnabledState(...).value */
     isAnnouncementEnabled(signal: AccessibilitySignal): boolean;
+    /** @deprecated Use getEnabledState(...).onChange */
     onSoundEnabledChanged(signal: AccessibilitySignal): Event<void>;
-    onAnnouncementEnabledChanged(signal: AccessibilitySignal): Event<void>;
-    playSound(signal: Sound, allowManyInParallel?: boolean): Promise<void>;
-    playSignalLoop(signal: AccessibilitySignal, milliseconds: number): IDisposable;
 }
 
 export { IAccessibilitySignalService };

package/vscode/src/vs/platform/accessibilitySignal/browser/progressAccessibilitySignalScheduler.js

@@ -0,0 +1,25 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from '../../../base/common/async.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { AccessibilitySignal } from './accessibilitySignalService.js';
+import { IAccessibilitySignalService } from './accessibilitySignalService.service.js';
+const PROGRESS_SIGNAL_LOOP_DELAY = 5000;
+let AccessibilityProgressSignalScheduler = class AccessibilityProgressSignalScheduler extends Disposable {
+    constructor(msDelayTime, msLoopTime, _accessibilitySignalService) {
+        super();
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._scheduler = ( new RunOnceScheduler(() => {
+            this._signalLoop = this._accessibilitySignalService.playSignalLoop(AccessibilitySignal.progress, msLoopTime ?? PROGRESS_SIGNAL_LOOP_DELAY);
+        }, msDelayTime));
+        this._scheduler.schedule();
+    }
+    dispose() {
+        super.dispose();
+        this._signalLoop?.dispose();
+        this._scheduler.dispose();
+    }
+};
+AccessibilityProgressSignalScheduler = ( __decorate([
+    ( __param(2, IAccessibilitySignalService))
+], AccessibilityProgressSignalScheduler));
+export { AccessibilityProgressSignalScheduler };

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.js

@@ -63,8 +63,8 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
     focusNext() {
         this._list?.value?.focusNext();
     }
-    hide() {
-        this._list.value?.hide();
+    hide(didCancel) {
+        this._list.value?.hide(didCancel);
         this._list.clear();
     }
     clear() {
@@ -103,7 +103,7 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         const width = this._list.value?.layout(actionBarWidth);
         widget.style.width = `${width}px`;
         const focusTracker = renderDisposables.add(trackFocus(element));
-        renderDisposables.add(focusTracker.onDidBlur(() => this.hide()));
+        renderDisposables.add(focusTracker.onDidBlur(() => this.hide(true)));
         return renderDisposables;
     }
     _createActionBar(className, actions) {
@@ -140,7 +140,7 @@ registerAction2(class extends Action2 {
         });
     }
     run(accessor) {
-        accessor.get(IActionWidgetService).hide();
+        accessor.get(IActionWidgetService).hide(true);
     }
 });
 registerAction2(class extends Action2 {

package/vscode/src/vs/platform/actions/browser/buttonbar.js

@@ -1,7 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { ButtonBar } from '../../../base/browser/ui/button/button.js';
 import { createInstantHoverDelegate } from '../../../base/browser/ui/hover/hoverDelegateFactory.js';
-import { setupCustomHover } from '../../../base/browser/ui/hover/updatableHoverWidget.js';
 import { ActionRunner, SubmenuAction } from '../../../base/common/actions.js';
 import { Emitter } from '../../../base/common/event.js';
 import { DisposableStore } from '../../../base/common/lifecycle.js';
@@ -11,15 +10,17 @@ import { MenuItemAction } from '../common/actions.js';
 import { IMenuService } from '../common/actions.service.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
+import { IHoverService } from '../../hover/browser/hover.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
 const _moduleId = "vs/platform/actions/browser/buttonbar";
 let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
-    constructor(container, _options, _contextMenuService, _keybindingService, telemetryService) {
+    constructor(container, _options, _contextMenuService, _keybindingService, telemetryService, _hoverService) {
         super(container);
         this._options = _options;
         this._contextMenuService = _contextMenuService;
         this._keybindingService = _keybindingService;
+        this._hoverService = _hoverService;
         this._store = ( (new DisposableStore()));
         this._updateStore = ( (new DisposableStore()));
         this._onDidChange = ( (new Emitter()));
@@ -89,7 +90,7 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
             else {
                 tooltip = action.label;
             }
-            this._updateStore.add(setupCustomHover(hoverDelegate, btn.element, tooltip));
+            this._updateStore.add(this._hoverService.setupUpdatableHover(hoverDelegate, btn.element, tooltip));
             this._updateStore.add(btn.onDidClick(async () => {
                 this._actionRunner.run(action);
             }));
@@ -100,11 +101,12 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
 WorkbenchButtonBar = ( (__decorate([
     ( (__param(2, IContextMenuService))),
     ( (__param(3, IKeybindingService))),
-    ( (__param(4, ITelemetryService)))
+    ( (__param(4, ITelemetryService))),
+    ( (__param(5, IHoverService)))
 ], WorkbenchButtonBar)));
 let MenuWorkbenchButtonBar = class MenuWorkbenchButtonBar extends WorkbenchButtonBar {
-    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService) {
-        super(container, options, contextMenuService, keybindingService, telemetryService);
+    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService, hoverService) {
+        super(container, options, contextMenuService, keybindingService, telemetryService, hoverService);
         const menu = menuService.createMenu(menuId, contextKeyService);
         this._store.add(menu);
         const update = () => {
@@ -129,6 +131,7 @@ MenuWorkbenchButtonBar = ( (__decorate([
     ( (__param(4, IContextKeyService))),
     ( (__param(5, IContextMenuService))),
     ( (__param(6, IKeybindingService))),
-    ( (__param(7, ITelemetryService)))
+    ( (__param(7, ITelemetryService))),
+    ( (__param(8, IHoverService)))
 ], MenuWorkbenchButtonBar)));
 export { MenuWorkbenchButtonBar, WorkbenchButtonBar };

package/vscode/src/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem.js

@@ -33,7 +33,7 @@ let DropdownWithPrimaryActionViewItem = class DropdownWithPrimaryActionViewItem
             this._primaryAction.actionRunner = _options.actionRunner;
         }
         this._dropdown = ( new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
-            menuAsChild: true,
+            menuAsChild: _options?.menuAsChild ?? true,
             classNames: className ? ['codicon', 'codicon-chevron-down', className] : ['codicon', 'codicon-chevron-down'],
             actionRunner: this._options?.actionRunner,
             keybindingProvider: this._options?.getKeyBinding,