@codingame/monaco-vscode-accessibility-service-override 4.5.1 → 5.0.0

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

@@ -0,0 +1,244 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import 'vscode/vscode/vs/base/common/arrays';
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { autorunWithStore, autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import { observableFromValueWithChangeEvent, observableFromEvent, wasEventTriggeredRecently, observableSignalFromEvent, observableFromPromise } from 'vscode/vscode/vs/base/common/observableInternal/utils';
+import 'vscode/vscode/vs/base/common/cancellation';
+import { isDefined } from 'vscode/vscode/vs/base/common/types';
+import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { FoldingController } from 'vscode/vscode/vs/editor/contrib/folding/browser/folding';
+import { AccessibilitySignal } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { MarkerSeverity } from 'vscode/vscode/vs/platform/markers/common/markers';
+import { IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers.service';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+
+let EditorTextPropertySignalsContribution = class EditorTextPropertySignalsContribution extends Disposable {
+    constructor(_editorService, _instantiationService, _accessibilitySignalService) {
+        super();
+        this._editorService = _editorService;
+        this._instantiationService = _instantiationService;
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._textProperties = [
+            this._instantiationService.createInstance(MarkerTextProperty, AccessibilitySignal.errorAtPosition, AccessibilitySignal.errorOnLine, MarkerSeverity.Error),
+            this._instantiationService.createInstance(MarkerTextProperty, AccessibilitySignal.warningAtPosition, AccessibilitySignal.warningOnLine, MarkerSeverity.Warning),
+            this._instantiationService.createInstance(FoldedAreaTextProperty),
+            this._instantiationService.createInstance(BreakpointTextProperty),
+        ];
+        this._someAccessibilitySignalIsEnabled = derived(this, reader => ( this._textProperties
+            .flatMap(p => [p.lineSignal, p.positionSignal])
+            .filter(isDefined)
+            .some(
+            signal => observableFromValueWithChangeEvent(this, this._accessibilitySignalService.getEnabledState(signal, false)).read(reader)
+        )));
+        this._activeEditorObservable = observableFromEvent(this._editorService.onDidActiveEditorChange, (_) => {
+            const activeTextEditorControl = this._editorService.activeTextEditorControl;
+            const editor = isDiffEditor(activeTextEditorControl)
+                ? activeTextEditorControl.getOriginalEditor()
+                : isCodeEditor(activeTextEditorControl)
+                    ? activeTextEditorControl
+                    : undefined;
+            return editor && editor.hasModel() ? { editor, model: editor.getModel() } : undefined;
+        });
+        this._register(autorunWithStore((reader, store) => {
+            if (!this._someAccessibilitySignalIsEnabled.read(reader)) {
+                return;
+            }
+            const activeEditor = this._activeEditorObservable.read(reader);
+            if (activeEditor) {
+                this._registerAccessibilitySignalsForEditor(activeEditor.editor, activeEditor.model, store);
+            }
+        }));
+    }
+    _registerAccessibilitySignalsForEditor(editor, editorModel, store) {
+        let lastLine = -1;
+        const ignoredLineSignalsForCurrentLine = ( new Set());
+        const timeouts = ( new DisposableStore());
+        const propertySources = ( this._textProperties.map(p => ({ source: p.createSource(editor, editorModel), property: p })));
+        const didType = wasEventTriggeredRecently(editor.onDidChangeModelContent, 100, store);
+        store.add(editor.onDidChangeCursorPosition(args => {
+            timeouts.clear();
+            if (args &&
+                args.reason !== 3  &&
+                args.reason !== 0 ) {
+                ignoredLineSignalsForCurrentLine.clear();
+                return;
+            }
+            const trigger = (property, source, mode) => {
+                const signal = mode === 'line' ? property.lineSignal : property.positionSignal;
+                if (!signal
+                    || !this._accessibilitySignalService.getEnabledState(signal, false).value
+                    || !source.isPresent(position, mode, undefined)) {
+                    return;
+                }
+                for (const modality of ['sound', 'announcement']) {
+                    if (this._accessibilitySignalService.getEnabledState(signal, false, modality)) {
+                        const delay = this._getDelay(signal, modality) + (didType.get() ? 1000 : 0);
+                        timeouts.add(disposableTimeout(() => {
+                            if (source.isPresent(position, mode, undefined)) {
+                                if (!(mode === 'line') || !( ignoredLineSignalsForCurrentLine.has(property))) {
+                                    this._accessibilitySignalService.playSignal(signal, { modality });
+                                }
+                                ignoredLineSignalsForCurrentLine.add(property);
+                            }
+                        }, delay));
+                    }
+                }
+            };
+            const position = args.position;
+            const lineNumber = position.lineNumber;
+            if (lineNumber !== lastLine) {
+                ignoredLineSignalsForCurrentLine.clear();
+                lastLine = lineNumber;
+                for (const p of propertySources) {
+                    trigger(p.property, p.source, 'line');
+                }
+            }
+            for (const p of propertySources) {
+                trigger(p.property, p.source, 'positional');
+            }
+            for (const s of propertySources) {
+                if (!( [s.property.lineSignal, s.property.positionSignal]
+                    .some(s => s && this._accessibilitySignalService.getEnabledState(s, false).value))) {
+                    return;
+                }
+                let lastValueAtPosition = undefined;
+                let lastValueOnLine = undefined;
+                timeouts.add(autorun(reader => {
+                    const newValueAtPosition = s.source.isPresentAtPosition(args.position, reader);
+                    const newValueOnLine = s.source.isPresentOnLine(args.position.lineNumber, reader);
+                    if (lastValueAtPosition !== undefined && lastValueAtPosition !== undefined) {
+                        if (!lastValueAtPosition && newValueAtPosition) {
+                            trigger(s.property, s.source, 'positional');
+                        }
+                        if (!lastValueOnLine && newValueOnLine) {
+                            trigger(s.property, s.source, 'line');
+                        }
+                    }
+                    lastValueAtPosition = newValueAtPosition;
+                    lastValueOnLine = newValueOnLine;
+                }));
+            }
+        }));
+    }
+    _getDelay(signal, modality) {
+        if (signal === AccessibilitySignal.errorAtPosition || signal === AccessibilitySignal.warningAtPosition) {
+            if (modality === 'sound') {
+                return 100;
+            }
+            else {
+                return 1000;
+            }
+        }
+        if (modality === 'sound') {
+            return 400;
+        }
+        else {
+            return 3000;
+        }
+    }
+};
+EditorTextPropertySignalsContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IAccessibilitySignalService))
+], EditorTextPropertySignalsContribution));
+class TextPropertySource {
+    static { this.notPresent = ( new TextPropertySource({ isPresentAtPosition: () => false, isPresentOnLine: () => false })); }
+    constructor(options) {
+        this.isPresentOnLine = options.isPresentOnLine;
+        this.isPresentAtPosition = options.isPresentAtPosition ?? (() => false);
+    }
+    isPresent(position, mode, reader) {
+        return mode === 'line' ? this.isPresentOnLine(position.lineNumber, reader) : this.isPresentAtPosition(position, reader);
+    }
+}
+let MarkerTextProperty = class MarkerTextProperty {
+    constructor(positionSignal, lineSignal, severity, markerService) {
+        this.positionSignal = positionSignal;
+        this.lineSignal = lineSignal;
+        this.severity = severity;
+        this.markerService = markerService;
+        this.debounceWhileTyping = true;
+    }
+    createSource(editor, model) {
+        const obs = observableSignalFromEvent('onMarkerChanged', this.markerService.onMarkerChanged);
+        return ( new TextPropertySource({
+            isPresentAtPosition: (position, reader) => {
+                obs.read(reader);
+                const hasMarker = ( this.markerService
+                    .read({ resource: model.uri })
+                    .some((m) => m.severity === this.severity &&
+                    m.startLineNumber <= position.lineNumber &&
+                    position.lineNumber <= m.endLineNumber &&
+                    m.startColumn <= position.column &&
+                    position.column <= m.endColumn));
+                return hasMarker;
+            },
+            isPresentOnLine: (lineNumber, reader) => {
+                obs.read(reader);
+                const hasMarker = ( this.markerService
+                    .read({ resource: model.uri })
+                    .some((m) => m.severity === this.severity &&
+                    m.startLineNumber <= lineNumber &&
+                    lineNumber <= m.endLineNumber));
+                return hasMarker;
+            }
+        }));
+    }
+};
+MarkerTextProperty = ( __decorate([
+    ( __param(3, IMarkerService))
+], MarkerTextProperty));
+class FoldedAreaTextProperty {
+    constructor() {
+        this.lineSignal = AccessibilitySignal.foldedArea;
+    }
+    createSource(editor, _model) {
+        const foldingController = FoldingController.get(editor);
+        if (!foldingController) {
+            return TextPropertySource.notPresent;
+        }
+        const foldingModel = observableFromPromise(foldingController.getFoldingModel() ?? Promise.resolve(undefined));
+        return ( new TextPropertySource({
+            isPresentOnLine(lineNumber, reader) {
+                const m = foldingModel.read(reader);
+                const regionAtLine = m.value?.getRegionAtLine(lineNumber);
+                const hasFolding = !regionAtLine
+                    ? false
+                    : regionAtLine.isCollapsed &&
+                        regionAtLine.startLineNumber === lineNumber;
+                return hasFolding;
+            }
+        }));
+    }
+}
+let BreakpointTextProperty = class BreakpointTextProperty {
+    constructor(debugService) {
+        this.debugService = debugService;
+        this.lineSignal = AccessibilitySignal.break;
+    }
+    createSource(editor, model) {
+        const signal = observableSignalFromEvent('onDidChangeBreakpoints', this.debugService.getModel().onDidChangeBreakpoints);
+        const debugService = this.debugService;
+        return ( new TextPropertySource({
+            isPresentOnLine(lineNumber, reader) {
+                signal.read(reader);
+                const breakpoints = debugService
+                    .getModel()
+                    .getBreakpoints({ uri: model.uri, lineNumber });
+                const hasBreakpoints = breakpoints.length > 0;
+                return hasBreakpoints;
+            }
+        }));
+    }
+};
+BreakpointTextProperty = ( __decorate([
+    ( __param(0, IDebugService))
+], BreakpointTextProperty));
+
+export { EditorTextPropertySignalsContribution };

package/vscode/src/vs/workbench/contrib/{accessibility → accessibilitySignals}/browser/openDiffEditorAnnouncement.js

@@ -7,6 +7,7 @@ import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/c
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 
+const _moduleId = "vs/workbench/contrib/accessibilitySignals/browser/openDiffEditorAnnouncement";
 let DiffEditorActiveAnnouncementContribution = class DiffEditorActiveAnnouncementContribution extends Disposable {
     static { this.ID = 'workbench.contrib.diffEditorActiveAnnouncement'; }
     constructor(_editorService, _accessibilityService, _configurationService) {
@@ -34,19 +35,15 @@ let DiffEditorActiveAnnouncementContribution = class DiffEditorActiveAnnouncemen
         }
         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"
-                )));
+                this._accessibilityService.alert(( localizeWithPath(_moduleId, 0, "Diff editor")));
             }
         }));
     }
 };
-DiffEditorActiveAnnouncementContribution = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IAccessibilityService)),
-    ( __param(2, IConfigurationService))
-], DiffEditorActiveAnnouncementContribution));
+DiffEditorActiveAnnouncementContribution = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IAccessibilityService))),
+    ( (__param(2, IConfigurationService)))
+], DiffEditorActiveAnnouncementContribution)));
 
 export { DiffEditorActiveAnnouncementContribution };

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

@@ -0,0 +1,42 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { isHotReloadEnabled } from 'vscode/vscode/vs/base/common/hotReload';
+import 'vscode/vscode/vs/base/common/arrays';
+import 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { autorunWithStore } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import 'vscode/vscode/vs/base/common/observableInternal/utils';
+import 'vscode/vscode/vs/base/common/cancellation';
+import { readHotReloadableExport } from 'vscode/vscode/vs/editor/browser/widget/diffEditor/utils';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+function wrapInReloadableClass(getClass) {
+    if (!isHotReloadEnabled()) {
+        return getClass();
+    }
+    return class ReloadableWrapper extends BaseClass {
+        constructor() {
+            super(...arguments);
+            this._autorun = undefined;
+        }
+        init() {
+            this._autorun = autorunWithStore((reader, store) => {
+                const clazz = readHotReloadableExport(getClass(), reader);
+                store.add(this.instantiationService.createInstance(clazz));
+            });
+        }
+        dispose() {
+            this._autorun?.dispose();
+        }
+    };
+}
+let BaseClass = class BaseClass {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.init();
+    }
+    init() { }
+};
+BaseClass = ( __decorate([
+    ( __param(0, IInstantiationService))
+], BaseClass));
+
+export { wrapInReloadableClass };

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

@@ -7,15 +7,19 @@ import { accessibilityHelpIsShown } from 'vscode/vscode/vs/workbench/contrib/acc
 import { alert } from 'vscode/vscode/vs/base/browser/ui/aria/aria';
 import { AccessibilityHelpNLS } from 'vscode/vscode/vs/editor/common/standaloneStrings';
 
+const _moduleId = "vs/workbench/contrib/codeEditor/browser/accessibility/accessibility";
 class ToggleScreenReaderMode extends Action2 {
     constructor() {
         super({
             id: 'editor.action.toggleScreenReaderAccessibilityMode',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/codeEditor/browser/accessibility/accessibility',
-                'toggleScreenReaderMode',
-                "Toggle Screen Reader Accessibility Mode"
-            )),
+            title: ( localize2WithPath(_moduleId, 0, "Toggle Screen Reader Accessibility Mode")),
+            metadata: {
+                description: ( localize2WithPath(
+                    _moduleId,
+                    1,
+                    "Toggles an optimized mode for usage with screen readers, braille devices, and other assistive technologies."
+                )),
+            },
             f1: true,
             keybinding: [{
                     primary: 2048  | 35 ,

package/vscode/src/vs/workbench/contrib/speech/browser/speechAccessibilitySignal.js

@@ -0,0 +1,22 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { AccessibilitySignal } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import { ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService.service';
+
+let SpeechAccessibilitySignalContribution = class SpeechAccessibilitySignalContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.speechAccessibilitySignal'; }
+    constructor(_accessibilitySignalService, _speechService) {
+        super();
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._speechService = _speechService;
+        this._register(this._speechService.onDidStartSpeechToTextSession(() => this._accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStarted)));
+        this._register(this._speechService.onDidEndSpeechToTextSession(() => this._accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStopped)));
+    }
+};
+SpeechAccessibilitySignalContribution = ( __decorate([
+    ( __param(0, IAccessibilitySignalService)),
+    ( __param(1, ISpeechService))
+], SpeechAccessibilitySignalContribution));
+
+export { SpeechAccessibilitySignalContribution };