@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

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

@@ -0,0 +1,430 @@
+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.isEnabledCache = ( new Cache((cue) => {
+            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(cue.settingsKey)), () => this.configurationService.getValue(cue.settingsKey));
+            return derived(reader => {
+                const setting = settingObservable.read(reader);
+                if (setting === 'on' ||
+                    (setting === 'auto' && this.screenReaderAttached.read(reader))) {
+                    return true;
+                }
+                const obsoleteSetting = this.obsoleteAudioCuesEnabled.read(reader);
+                if (obsoleteSetting === 'on' ||
+                    (obsoleteSetting === 'auto' && this.screenReaderAttached.read(reader))) {
+                    return true;
+                }
+                return false;
+            });
+        }));
+    }
+    async playAudioCue(cue, options = {}) {
+        if (this.isEnabled(cue)) {
+            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 sounds = ( new Set(( ( cues.map(c => 'cue' in c ? c.cue : c)).filter(cue => this.isEnabled(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);
+    }
+    isEnabled(cue) {
+        return this.isEnabledCache.get(cue).get();
+    }
+    onEnabledChanged(cue) {
+        return Event.fromObservableLight(this.isEnabledCache.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) {
+        this.getValue = getValue;
+        this.map = ( new Map());
+    }
+    get(arg) {
+        if (( this.map.has(arg))) {
+            return this.map.get(arg);
+        }
+        const value = this.getValue(arg);
+        this.map.set(arg, 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));
+        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',
+    }); }
+    static { this.warning = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.lineHasWarning.name',
+            'Warning on Line'
+        )),
+        sound: Sound.warning,
+        settingsKey: 'audioCues.lineHasWarning',
+    }); }
+    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',
+    }); }
+    static { this.break = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.lineHasBreakpoint.name',
+            'Breakpoint on Line'
+        )),
+        sound: Sound.break,
+        settingsKey: 'audioCues.lineHasBreakpoint',
+    }); }
+    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',
+    }); }
+    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',
+    }); }
+    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'
+    }); }
+    static { this.taskCompleted = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.taskCompleted',
+            'Task Completed'
+        )),
+        sound: Sound.taskCompleted,
+        settingsKey: 'audioCues.taskCompleted'
+    }); }
+    static { this.taskFailed = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.taskFailed',
+            'Task Failed'
+        )),
+        sound: Sound.taskFailed,
+        settingsKey: 'audioCues.taskFailed'
+    }); }
+    static { this.terminalCommandFailed = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.terminalCommandFailed',
+            'Terminal Command Failed'
+        )),
+        sound: Sound.error,
+        settingsKey: 'audioCues.terminalCommandFailed'
+    }); }
+    static { this.terminalBell = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.terminalBell',
+            'Terminal Bell'
+        )),
+        sound: Sound.terminalBell,
+        settingsKey: 'audioCues.terminalBell'
+    }); }
+    static { this.notebookCellCompleted = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.notebookCellCompleted',
+            'Notebook Cell Completed'
+        )),
+        sound: Sound.taskCompleted,
+        settingsKey: 'audioCues.notebookCellCompleted'
+    }); }
+    static { this.notebookCellFailed = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.notebookCellFailed',
+            'Notebook Cell Failed'
+        )),
+        sound: Sound.taskFailed,
+        settingsKey: 'audioCues.notebookCellFailed'
+    }); }
+    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'
+    }); }
+    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'
+    }); }
+    static { this.clear = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.clear',
+            'Clear'
+        )),
+        sound: Sound.clear,
+        settingsKey: 'audioCues.clear'
+    }); }
+    static { this.save = AudioCue.register({
+        name: ( localizeWithPath('vs/platform/audioCues/browser/audioCueService', 'audioCues.save', 'Save')),
+        sound: Sound.save,
+        settingsKey: 'audioCues.save'
+    }); }
+    static { this.format = AudioCue.register({
+        name: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.format',
+            'Format'
+        )),
+        sound: Sound.format,
+        settingsKey: 'audioCues.format'
+    }); }
+    constructor(sound, name, settingsKey) {
+        this.sound = sound;
+        this.name = name;
+        this.settingsKey = settingsKey;
+    }
+}
+export { AudioCue, AudioCueService, IAudioCueService, Sound, SoundSource };

package/vscode/src/vs/platform/clipboard/browser/clipboardService.js

@@ -0,0 +1,103 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { isSafari, isWebkitWebView } from '../../../base/browser/browser.js';
+import { addDisposableListener, getActiveDocument, $ } from '../../../base/browser/dom.js';
+import { DeferredPromise } from '../../../base/common/async.js';
+import { Event } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { ILayoutService } from '../../layout/browser/layoutService.js';
+import { ILogService } from '../../log/common/log.js';
+let BrowserClipboardService = class BrowserClipboardService extends Disposable {
+    constructor(layoutService, logService) {
+        super();
+        this.layoutService = layoutService;
+        this.logService = logService;
+        this.mapTextToType = ( new Map());
+        this.findText = '';
+        this.resources = [];
+        if (isSafari || isWebkitWebView) {
+            this.installWebKitWriteTextWorkaround();
+        }
+    }
+    installWebKitWriteTextWorkaround() {
+        const handler = () => {
+            const currentWritePromise = ( new DeferredPromise());
+            if (this.webKitPendingClipboardWritePromise && !this.webKitPendingClipboardWritePromise.isSettled) {
+                this.webKitPendingClipboardWritePromise.cancel();
+            }
+            this.webKitPendingClipboardWritePromise = currentWritePromise;
+            navigator.clipboard.write([( new ClipboardItem({
+                    'text/plain': currentWritePromise.p,
+                }))]).catch(async (err) => {
+                if (!(err instanceof Error) || err.name !== 'NotAllowedError' || !currentWritePromise.isRejected) {
+                    this.logService.error(err);
+                }
+            });
+        };
+        this._register(Event.runAndSubscribe(this.layoutService.onDidAddContainer, ({ container, disposables }) => {
+            disposables.add(addDisposableListener(container, 'click', handler));
+            disposables.add(addDisposableListener(container, 'keydown', handler));
+        }, { container: this.layoutService.mainContainer, disposables: this._store }));
+    }
+    async writeText(text, type) {
+        if (type) {
+            this.mapTextToType.set(type, text);
+            return;
+        }
+        if (this.webKitPendingClipboardWritePromise) {
+            return this.webKitPendingClipboardWritePromise.complete(text);
+        }
+        try {
+            return await navigator.clipboard.writeText(text);
+        }
+        catch (error) {
+            console.error(error);
+        }
+        const activeDocument = getActiveDocument();
+        const activeElement = activeDocument.activeElement;
+        const textArea = activeDocument.body.appendChild($('textarea', { 'aria-hidden': true }));
+        textArea.style.height = '1px';
+        textArea.style.width = '1px';
+        textArea.style.position = 'absolute';
+        textArea.value = text;
+        textArea.focus();
+        textArea.select();
+        activeDocument.execCommand('copy');
+        if (activeElement instanceof HTMLElement) {
+            activeElement.focus();
+        }
+        activeDocument.body.removeChild(textArea);
+        return;
+    }
+    async readText(type) {
+        if (type) {
+            return this.mapTextToType.get(type) || '';
+        }
+        try {
+            return await navigator.clipboard.readText();
+        }
+        catch (error) {
+            console.error(error);
+            return '';
+        }
+    }
+    async readFindText() {
+        return this.findText;
+    }
+    async writeFindText(text) {
+        this.findText = text;
+    }
+    async writeResources(resources) {
+        this.resources = resources;
+    }
+    async readResources() {
+        return this.resources;
+    }
+    async hasResources() {
+        return this.resources.length > 0;
+    }
+};
+BrowserClipboardService = ( __decorate([
+    ( __param(0, ILayoutService)),
+    ( __param(1, ILogService))
+], BrowserClipboardService));
+export { BrowserClipboardService };

package/vscode/src/vs/platform/clipboard/common/clipboardService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+const IClipboardService = ( createDecorator('clipboardService'));
+export { IClipboardService };

package/vscode/src/vs/platform/commands/common/commands.js

@@ -0,0 +1,74 @@
+import { Emitter } from '../../../base/common/event.js';
+import { Iterable } from '../../../base/common/iterator.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { LinkedList } from '../../../base/common/linkedList.js';
+import { validateConstraints } from '../../../base/common/types.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+const ICommandService = ( createDecorator('commandService'));
+const CommandsRegistry = new (class {
+    constructor() {
+        this._commands = ( new Map());
+        this._onDidRegisterCommand = ( new Emitter());
+        this.onDidRegisterCommand = this._onDidRegisterCommand.event;
+    }
+    registerCommand(idOrCommand, handler) {
+        if (!idOrCommand) {
+            throw new Error(`invalid command`);
+        }
+        if (typeof idOrCommand === 'string') {
+            if (!handler) {
+                throw new Error(`invalid command`);
+            }
+            return this.registerCommand({ id: idOrCommand, handler });
+        }
+        if (idOrCommand.metadata && Array.isArray(idOrCommand.metadata.args)) {
+            const constraints = [];
+            for (const arg of idOrCommand.metadata.args) {
+                constraints.push(arg.constraint);
+            }
+            const actualHandler = idOrCommand.handler;
+            idOrCommand.handler = function (accessor, ...args) {
+                validateConstraints(args, constraints);
+                return actualHandler(accessor, ...args);
+            };
+        }
+        const { id } = idOrCommand;
+        let commands = this._commands.get(id);
+        if (!commands) {
+            commands = ( new LinkedList());
+            this._commands.set(id, commands);
+        }
+        const removeFn = commands.unshift(idOrCommand);
+        const ret = toDisposable(() => {
+            removeFn();
+            const command = this._commands.get(id);
+            if (command?.isEmpty()) {
+                this._commands.delete(id);
+            }
+        });
+        this._onDidRegisterCommand.fire(id);
+        return ret;
+    }
+    registerCommandAlias(oldId, newId) {
+        return CommandsRegistry.registerCommand(oldId, (accessor, ...args) => accessor.get(ICommandService).executeCommand(newId, ...args));
+    }
+    getCommand(id) {
+        const list = this._commands.get(id);
+        if (!list || list.isEmpty()) {
+            return undefined;
+        }
+        return Iterable.first(list);
+    }
+    getCommands() {
+        const result = ( new Map());
+        for (const key of ( this._commands.keys())) {
+            const command = this.getCommand(key);
+            if (command) {
+                result.set(key, command);
+            }
+        }
+        return result;
+    }
+});
+CommandsRegistry.registerCommand('noop', () => { });
+export { CommandsRegistry, ICommandService };