@codingame/monaco-vscode-api 2.2.1 → 3.0.0

package/vscode/src/vs/platform/audioCues/browser/audioCueService.js

@@ -1,576 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
-import { FileAccess } from '../../../base/common/network.js';
-import { IAccessibilityService } from '../../accessibility/common/accessibility.js';
-import { IConfigurationService } from '../../configuration/common/configuration.js';
-import { createDecorator } from '../../instantiation/common/instantiation.js';
-import { Event } from '../../../base/common/event.js';
-import { localizeWithPath } from '../../../nls.js';
-import { ITelemetryService } from '../../telemetry/common/telemetry.js';
-import { observableFromEvent } from '../../../base/common/observableInternal/utils.js';
-import { derived } from '../../../base/common/observableInternal/derived.js';
-const IAudioCueService = ( createDecorator('audioCue'));
-let AudioCueService = class AudioCueService extends Disposable {
-    constructor(configurationService, accessibilityService, telemetryService) {
-        super();
-        this.configurationService = configurationService;
-        this.accessibilityService = accessibilityService;
-        this.telemetryService = telemetryService;
-        this.sounds = ( new Map());
-        this.screenReaderAttached = observableFromEvent(this.accessibilityService.onDidChangeScreenReaderOptimized, () =>  this.accessibilityService.isScreenReaderOptimized());
-        this.sentTelemetry = ( new Set());
-        this.playingSounds = ( new Set());
-        this.obsoleteAudioCuesEnabled = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration('audioCues.enabled')), () =>  this.configurationService.getValue('audioCues.enabled'));
-        this.isCueEnabledCache = ( new Cache((event) => {
-            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.cue.settingsKey)), () => this.configurationService.getValue(event.cue.settingsKey));
-            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 obsoleteSetting = this.obsoleteAudioCuesEnabled.read(reader);
-                if (obsoleteSetting === 'on' ||
-                    (obsoleteSetting === 'auto' && this.screenReaderAttached.read(reader))) {
-                    return true;
-                }
-                return false;
-            });
-        }, JSON.stringify));
-        this.isAlertEnabledCache = ( new Cache((event) => {
-            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.cue.settingsKey)), () => event.cue.alertSettingsKey ? this.configurationService.getValue(event.cue.alertSettingsKey) : false);
-            return derived(reader => {
-                const setting = settingObservable.read(reader);
-                if (!this.screenReaderAttached.read(reader)) {
-                    return false;
-                }
-                return setting === true || setting === 'always' || setting === 'userGesture' && event.userGesture;
-            });
-        }, JSON.stringify));
-    }
-    async playAudioCue(cue, options = {}) {
-        const alertMessage = cue.alertMessage;
-        if (this.isAlertEnabled(cue, options.userGesture) && alertMessage) {
-            this.accessibilityService.status(alertMessage);
-        }
-        if (this.isCueEnabled(cue, options.userGesture)) {
-            this.sendAudioCueTelemetry(cue, options.source);
-            await this.playSound(cue.sound.getSound(), options.allowManyInParallel);
-        }
-    }
-    async playAudioCues(cues) {
-        for (const cue of cues) {
-            this.sendAudioCueTelemetry('cue' in cue ? cue.cue : cue, 'source' in cue ? cue.source : undefined);
-        }
-        const cueArray = ( cues.map(c => 'cue' in c ? c.cue : c));
-        const alerts = ( cueArray.filter(cue => this.isAlertEnabled(cue)).map(c => c.alertMessage));
-        if (alerts.length) {
-            this.accessibilityService.status(alerts.join(', '));
-        }
-        const sounds = ( new Set(( cueArray.filter(cue => this.isCueEnabled(cue)).map(cue => cue.sound.getSound()))));
-        await Promise.all(( Array.from(sounds).map(sound => this.playSound(sound, true))));
-    }
-    sendAudioCueTelemetry(cue, source) {
-        const isScreenReaderOptimized = this.accessibilityService.isScreenReaderOptimized();
-        const key = cue.name + (source ? `::${source}` : '') + (isScreenReaderOptimized ? '{screenReaderOptimized}' : '');
-        if (( this.sentTelemetry.has(key)) || this.getVolumeInPercent() === 0) {
-            return;
-        }
-        this.sentTelemetry.add(key);
-        this.telemetryService.publicLog2('audioCue.played', {
-            audioCue: cue.name,
-            source: source ?? '',
-            isScreenReaderOptimized,
-        });
-    }
-    getVolumeInPercent() {
-        const volume = this.configurationService.getValue('audioCues.volume');
-        if (typeof volume !== 'number') {
-            return 50;
-        }
-        return Math.max(Math.min(volume, 100), 0);
-    }
-    async playSound(sound, allowManyInParallel = false) {
-        if (!allowManyInParallel && ( this.playingSounds.has(sound))) {
-            return;
-        }
-        this.playingSounds.add(sound);
-        const url = ( ( FileAccess.asBrowserUri(`vs/platform/audioCues/browser/media/${sound.fileName}`)).toString(true));
-        try {
-            const sound = this.sounds.get(url);
-            if (sound) {
-                sound.volume = this.getVolumeInPercent() / 100;
-                sound.currentTime = 0;
-                await sound.play();
-            }
-            else {
-                const playedSound = await playAudio(url, this.getVolumeInPercent() / 100);
-                this.sounds.set(url, playedSound);
-            }
-        }
-        catch (e) {
-            if (!e.message.includes('play() can only be initiated by a user gesture')) {
-                console.error('Error while playing sound', e);
-            }
-        }
-        finally {
-            this.playingSounds.delete(sound);
-        }
-    }
-    playAudioCueLoop(cue, milliseconds) {
-        let playing = true;
-        const playSound = () => {
-            if (playing) {
-                this.playAudioCue(cue, { allowManyInParallel: true }).finally(() => {
-                    setTimeout(() => {
-                        if (playing) {
-                            playSound();
-                        }
-                    }, milliseconds);
-                });
-            }
-        };
-        playSound();
-        return toDisposable(() => playing = false);
-    }
-    isAlertEnabled(cue, userGesture) {
-        return this.isAlertEnabledCache.get({ cue, userGesture }).get() ?? false;
-    }
-    isCueEnabled(cue, userGesture) {
-        return this.isCueEnabledCache.get({ cue, userGesture }).get() ?? false;
-    }
-    onEnabledChanged(cue) {
-        return Event.fromObservableLight(this.isCueEnabledCache.get({ cue }));
-    }
-    onAlertEnabledChanged(cue) {
-        return Event.fromObservableLight(this.isAlertEnabledCache.get({ cue }));
-    }
-};
-AudioCueService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IAccessibilityService)),
-    ( __param(2, ITelemetryService))
-], AudioCueService));
-function playAudio(url, volume) {
-    return ( new Promise((resolve, reject) => {
-        const audio = ( new Audio(url));
-        audio.volume = volume;
-        audio.addEventListener('ended', () => {
-            resolve(audio);
-        });
-        audio.addEventListener('error', (e) => {
-            reject(e.error);
-        });
-        audio.play().catch(e => {
-            reject(e);
-        });
-    }));
-}
-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));
-        return sound;
-    }
-    static { this.error = Sound.register({ fileName: 'error.mp3' }); }
-    static { this.warning = Sound.register({ fileName: 'warning.mp3' }); }
-    static { this.foldedArea = Sound.register({ fileName: 'foldedAreas.mp3' }); }
-    static { this.break = Sound.register({ fileName: 'break.mp3' }); }
-    static { this.quickFixes = Sound.register({ fileName: 'quickFixes.mp3' }); }
-    static { this.taskCompleted = Sound.register({ fileName: 'taskCompleted.mp3' }); }
-    static { this.taskFailed = Sound.register({ fileName: 'taskFailed.mp3' }); }
-    static { this.terminalBell = Sound.register({ fileName: 'terminalBell.mp3' }); }
-    static { this.diffLineInserted = Sound.register({ fileName: 'diffLineInserted.mp3' }); }
-    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' }); }
-    static { this.chatResponseReceived4 = Sound.register({ fileName: 'chatResponseReceived4.mp3' }); }
-    static { this.clear = Sound.register({ fileName: 'clear.mp3' }); }
-    static { this.save = Sound.register({ fileName: 'save.mp3' }); }
-    static { this.format = Sound.register({ fileName: 'format.mp3' }); }
-    constructor(fileName) {
-        this.fileName = fileName;
-    }
-}
-class SoundSource {
-    constructor(randomOneOf) {
-        this.randomOneOf = randomOneOf;
-    }
-    getSound(deterministic = false) {
-        if (deterministic || this.randomOneOf.length === 1) {
-            return this.randomOneOf[0];
-        }
-        else {
-            const index = Math.floor(Math.random() * this.randomOneOf.length);
-            return this.randomOneOf[index];
-        }
-    }
-}
-class AudioCue {
-    static { this._audioCues = ( new Set()); }
-    static register(options) {
-        const soundSource = ( new SoundSource(
-            'randomOneOf' in options.sound ? options.sound.randomOneOf : [options.sound]
-        ));
-        const audioCue = ( new AudioCue(
-            soundSource,
-            options.name,
-            options.settingsKey,
-            options.alertSettingsKey,
-            options.alertMessage
-        ));
-        AudioCue._audioCues.add(audioCue);
-        return audioCue;
-    }
-    static get allAudioCues() {
-        return [...this._audioCues];
-    }
-    static { this.error = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasError.name',
-            'Error on Line'
-        )),
-        sound: Sound.error,
-        settingsKey: 'audioCues.lineHasError',
-        alertSettingsKey: "accessibility.alert.error" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasError.alertMessage',
-            'Error'
-        ))
-    }); }
-    static { this.warning = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasWarning.name',
-            'Warning on Line'
-        )),
-        sound: Sound.warning,
-        settingsKey: 'audioCues.lineHasWarning',
-        alertSettingsKey: "accessibility.alert.warning" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasWarning.alertMessage',
-            'Warning'
-        ))
-    }); }
-    static { this.foldedArea = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasFoldedArea.name',
-            'Folded Area on Line'
-        )),
-        sound: Sound.foldedArea,
-        settingsKey: 'audioCues.lineHasFoldedArea',
-        alertSettingsKey: "accessibility.alert.foldedArea" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasFoldedArea.alertMessage',
-            'Folded'
-        ))
-    }); }
-    static { this.break = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasBreakpoint.name',
-            'Breakpoint on Line'
-        )),
-        sound: Sound.break,
-        settingsKey: 'audioCues.lineHasBreakpoint',
-        alertSettingsKey: "accessibility.alert.breakpoint" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasBreakpoint.alertMessage',
-            'Breakpoint'
-        ))
-    }); }
-    static { this.inlineSuggestion = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.lineHasInlineSuggestion.name',
-            'Inline Suggestion on Line'
-        )),
-        sound: Sound.quickFixes,
-        settingsKey: 'audioCues.lineHasInlineSuggestion',
-    }); }
-    static { this.terminalQuickFix = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.terminalQuickFix.name',
-            'Terminal Quick Fix'
-        )),
-        sound: Sound.quickFixes,
-        settingsKey: 'audioCues.terminalQuickFix',
-        alertSettingsKey: "accessibility.alert.terminalQuickFix" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.terminalQuickFix.alertMessage',
-            'Quick Fix'
-        ))
-    }); }
-    static { this.onDebugBreak = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.onDebugBreak.name',
-            'Debugger Stopped on Breakpoint'
-        )),
-        sound: Sound.break,
-        settingsKey: 'audioCues.onDebugBreak',
-        alertSettingsKey: "accessibility.alert.onDebugBreak" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.onDebugBreak.alertMessage',
-            'Breakpoint'
-        ))
-    }); }
-    static { this.noInlayHints = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.noInlayHints',
-            'No Inlay Hints on Line'
-        )),
-        sound: Sound.error,
-        settingsKey: 'audioCues.noInlayHints',
-        alertSettingsKey: "accessibility.alert.noInlayHints" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.noInlayHints.alertMessage',
-            'No Inlay Hints'
-        ))
-    }); }
-    static { this.taskCompleted = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.taskCompleted',
-            'Task Completed'
-        )),
-        sound: Sound.taskCompleted,
-        settingsKey: 'audioCues.taskCompleted',
-        alertSettingsKey: "accessibility.alert.taskCompleted" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.taskCompleted.alertMessage',
-            'Task Completed'
-        ))
-    }); }
-    static { this.taskFailed = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.taskFailed',
-            'Task Failed'
-        )),
-        sound: Sound.taskFailed,
-        settingsKey: 'audioCues.taskFailed',
-        alertSettingsKey: "accessibility.alert.taskFailed" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.taskFailed.alertMessage',
-            'Task Failed'
-        ))
-    }); }
-    static { this.terminalCommandFailed = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.terminalCommandFailed',
-            'Terminal Command Failed'
-        )),
-        sound: Sound.error,
-        settingsKey: 'audioCues.terminalCommandFailed',
-        alertSettingsKey: "accessibility.alert.terminalCommandFailed" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.terminalCommandFailed.alertMessage',
-            'Command Failed'
-        ))
-    }); }
-    static { this.terminalBell = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.terminalBell',
-            'Terminal Bell'
-        )),
-        sound: Sound.terminalBell,
-        settingsKey: 'audioCues.terminalBell',
-        alertSettingsKey: "accessibility.alert.terminalBell" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.terminalBell.alertMessage',
-            'Terminal Bell'
-        ))
-    }); }
-    static { this.notebookCellCompleted = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.notebookCellCompleted',
-            'Notebook Cell Completed'
-        )),
-        sound: Sound.taskCompleted,
-        settingsKey: 'audioCues.notebookCellCompleted',
-        alertSettingsKey: "accessibility.alert.notebookCellCompleted" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.notebookCellCompleted.alertMessage',
-            'Notebook Cell Completed'
-        ))
-    }); }
-    static { this.notebookCellFailed = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.notebookCellFailed',
-            'Notebook Cell Failed'
-        )),
-        sound: Sound.taskFailed,
-        settingsKey: 'audioCues.notebookCellFailed',
-        alertSettingsKey: "accessibility.alert.notebookCellFailed" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.notebookCellFailed.alertMessage',
-            'Notebook Cell Failed'
-        ))
-    }); }
-    static { this.diffLineInserted = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.diffLineInserted',
-            'Diff Line Inserted'
-        )),
-        sound: Sound.diffLineInserted,
-        settingsKey: 'audioCues.diffLineInserted',
-    }); }
-    static { this.diffLineDeleted = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.diffLineDeleted',
-            'Diff Line Deleted'
-        )),
-        sound: Sound.diffLineDeleted,
-        settingsKey: 'audioCues.diffLineDeleted',
-    }); }
-    static { this.diffLineModified = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.diffLineModified',
-            'Diff Line Modified'
-        )),
-        sound: Sound.diffLineModified,
-        settingsKey: 'audioCues.diffLineModified',
-    }); }
-    static { this.chatRequestSent = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.chatRequestSent',
-            'Chat Request Sent'
-        )),
-        sound: Sound.chatRequestSent,
-        settingsKey: 'audioCues.chatRequestSent',
-        alertSettingsKey: "accessibility.alert.chatRequestSent" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.chatRequestSent.alertMessage',
-            'Chat Request Sent'
-        ))
-    }); }
-    static { this.chatResponseReceived = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.chatResponseReceived',
-            'Chat Response Received'
-        )),
-        settingsKey: 'audioCues.chatResponseReceived',
-        sound: {
-            randomOneOf: [
-                Sound.chatResponseReceived1,
-                Sound.chatResponseReceived2,
-                Sound.chatResponseReceived3,
-                Sound.chatResponseReceived4
-            ]
-        },
-    }); }
-    static { this.chatResponsePending = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.chatResponsePending',
-            'Chat Response Pending'
-        )),
-        sound: Sound.chatResponsePending,
-        settingsKey: 'audioCues.chatResponsePending',
-        alertSettingsKey: "accessibility.alert.chatResponsePending" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.chatResponsePending.alertMessage',
-            'Chat Response Pending'
-        ))
-    }); }
-    static { this.clear = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.clear',
-            'Clear'
-        )),
-        sound: Sound.clear,
-        settingsKey: 'audioCues.clear',
-        alertSettingsKey: "accessibility.alert.clear" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.clear.alertMessage',
-            'Clear'
-        ))
-    }); }
-    static { this.save = AudioCue.register({
-        name: ( localizeWithPath('vs/platform/audioCues/browser/audioCueService', 'audioCues.save', 'Save')),
-        sound: Sound.save,
-        settingsKey: 'audioCues.save',
-        alertSettingsKey: "accessibility.alert.save" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.save.alertMessage',
-            'Save'
-        ))
-    }); }
-    static { this.format = AudioCue.register({
-        name: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.format',
-            'Format'
-        )),
-        sound: Sound.format,
-        settingsKey: 'audioCues.format',
-        alertSettingsKey: "accessibility.alert.format" ,
-        alertMessage: ( localizeWithPath(
-            'vs/platform/audioCues/browser/audioCueService',
-            'audioCues.format.alertMessage',
-            'Format'
-        ))
-    }); }
-    constructor(sound, name, settingsKey, alertSettingsKey, alertMessage) {
-        this.sound = sound;
-        this.name = name;
-        this.settingsKey = settingsKey;
-        this.alertSettingsKey = alertSettingsKey;
-        this.alertMessage = alertMessage;
-    }
-}
-export { AudioCue, AudioCueService, IAudioCueService, Sound, SoundSource };