@codingame/monaco-vscode-api 1.76.2 → 1.76.3-next.0

package/dist/async.js

@@ -1,7 +1,10 @@
-import { E as Emitter } from './contextkey.js';
+import { E as Emitter } from './services2.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+function isThenable(obj) {
+    return !!obj && typeof obj.then === 'function';
+}
 function raceCancellationError(promise, token) {
     return ( new Promise((resolve, reject) => {
         const ref = token.onCancellationRequested(() => {
@@ -11,6 +14,28 @@ function raceCancellationError(promise, token) {
         promise.then(resolve, reject).finally(() => ref.dispose());
     }));
 }
+function raceTimeout(promise, timeout, onTimeout) {
+    let promiseResolve = undefined;
+    const timer = setTimeout(() => {
+        promiseResolve?.(undefined);
+        onTimeout?.();
+    }, timeout);
+    return Promise.race([
+        promise.finally(() => clearTimeout(timer)),
+        ( new Promise(resolve => promiseResolve = resolve))
+    ]);
+}
+function asPromise(callback) {
+    return ( new Promise((resolve, reject) => {
+        const item = callback();
+        if (isThenable(item)) {
+            item.then(resolve, reject);
+        }
+        else {
+            resolve(item);
+        }
+    }));
+}
 class Sequencer {
     constructor() {
         this.current = Promise.resolve(null);
@@ -37,6 +62,25 @@ class Barrier {
         return this._promise;
     }
 }
+function sequence(promiseFactories) {
+    const results = [];
+    let index = 0;
+    const len = promiseFactories.length;
+    function next() {
+        return index < len ? promiseFactories[index++]() : null;
+    }
+    function thenHandler(result) {
+        if (result !== undefined && result !== null) {
+            results.push(result);
+        }
+        const n = next();
+        if (n) {
+            return n.then(thenHandler);
+        }
+        return Promise.resolve(results);
+    }
+    return Promise.resolve(null).then(thenHandler);
+}
 class Limiter {
     constructor(maxDegreeOfParalellism) {
         this._size = 0;
@@ -141,6 +185,67 @@ class ResourceQueue {
         this.releaseDrainers();
     }
 }
+class TaskSequentializer {
+    hasPending(taskId) {
+        if (!this._pending) {
+            return false;
+        }
+        if (typeof taskId === 'number') {
+            return this._pending.taskId === taskId;
+        }
+        return !!this._pending;
+    }
+    get pending() {
+        return this._pending?.promise;
+    }
+    cancelPending() {
+        this._pending?.cancel();
+    }
+    setPending(taskId, promise, onCancel) {
+        this._pending = { taskId, cancel: () => onCancel?.(), promise };
+        promise.then(() => this.donePending(taskId), () => this.donePending(taskId));
+        return promise;
+    }
+    donePending(taskId) {
+        if (this._pending && taskId === this._pending.taskId) {
+            this._pending = undefined;
+            this.triggerNext();
+        }
+    }
+    triggerNext() {
+        if (this._next) {
+            const next = this._next;
+            this._next = undefined;
+            next.run().then(next.promiseResolve, next.promiseReject);
+        }
+    }
+    setNext(run) {
+        if (!this._next) {
+            let promiseResolve;
+            let promiseReject;
+            const promise = ( new Promise((resolve, reject) => {
+                promiseResolve = resolve;
+                promiseReject = reject;
+            }));
+            this._next = {
+                run,
+                promise,
+                promiseResolve: promiseResolve,
+                promiseReject: promiseReject
+            };
+        }
+        else {
+            this._next.run = run;
+        }
+        return this._next.promise;
+    }
+    hasNext() {
+        return !!this._next;
+    }
+    async join() {
+        return this._next?.promise ?? this._pending?.promise;
+    }
+}
 class IntervalCounter {
     constructor(interval, nowFn = () => Date.now()) {
         this.interval = interval;
@@ -193,4 +298,4 @@ class DeferredPromise {
     cancel() {
     }
 }
-export { Barrier as B, IntervalCounter as I, ResourceQueue as R, Sequencer as S, raceCancellationError as r };
+export { Barrier as B, IntervalCounter as I, Queue as Q, ResourceQueue as R, Sequencer as S, TaskSequentializer as T, asPromise as a, raceTimeout as b, raceCancellationError as r, sequence as s };

package/dist/audioCue.js

@@ -1,7 +1,6 @@
-import './polyfill.js';
-import { d as IPreferencesService, o as IDebugService } from './missing-services.js';
-import { _ as __decorate, a as __param } from './contextkey.js';
-import { b as IEditorService } from './services2.js';
+import { o as onServicesInitialized } from './polyfill.js';
+import { bS as IPreferencesService } from './missing-services.js';
+import { _ as __decorate, a as __param, I as IEditorService, u as IDebugService } from './services2.js';
 import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IAudioCueService, AudioCue as AudioCue$1 } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
 import { MarkerSeverity, IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
@@ -12,7 +11,6 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { FoldingController } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.js';
 import { GhostTextController } from 'monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/ghostTextController.js';
-import { o as onServicesInitialized } from './tools.js';
 import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
@@ -501,8 +499,10 @@ let AudioCueService = class AudioCueService extends Disposable {
         }
     }
     async playAudioCues(cues) {
-        const sounds = ( (new Set(cues.filter(cue => this.isEnabled(cue)).map(cue => cue.sound))));
-        await Promise.all(Array.from(sounds).map(sound => this.playSound(sound, true)));
+        const sounds = ( (new Set(
+             (cues.filter(cue => this.isEnabled(cue)).map(cue => cue.sound))
+        )));
+        await Promise.all(( (Array.from(sounds).map(sound => this.playSound(sound, true)))));
     }
     getVolumeInPercent() {
         const volume = this.configurationService.getValue('audioCues.volume');
@@ -722,85 +722,6 @@ AudioCue.diffLineModified = AudioCue.register({
     sound: Sound.diffLineModified,
     settingsKey: 'audioCues.diffLineModified'
 });
-class ShowAudioCueHelp extends Action2 {
-    constructor() {
-        super({
-            id: ShowAudioCueHelp.ID,
-            title: {
-                value: ( (localize('audioCues.help', "Help: List Audio Cues"))),
-                original: 'Help: List Audio Cues'
-            },
-            f1: true,
-        });
-    }
-    async run(accessor) {
-        const audioCueService = accessor.get(IAudioCueService);
-        const quickPickService = accessor.get(IQuickInputService);
-        const preferencesService = accessor.get(IPreferencesService);
-        const accessibilityService = accessor.get(IAccessibilityService);
-        const items = AudioCue$1.allAudioCues.map((cue, idx) => ({
-            label: accessibilityService.isScreenReaderOptimized() ?
-                `${cue.name}${audioCueService.isEnabled(cue) ? '' : ' (' + ( ( localize('disabled', "Disabled"))) + ')'}`
-                : `${audioCueService.isEnabled(cue) ? '$(check)' : '     '} ${cue.name}`,
-            audioCue: cue,
-            buttons: [{
-                    iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
-                    tooltip: ( (localize('audioCues.help.settings', 'Enable/Disable Audio Cue'))),
-                }],
-        }));
-        const quickPick = quickPickService.pick(items, {
-            activeItem: items[0],
-            onDidFocus: (item) => {
-                audioCueService.playSound(item.audioCue.sound, true);
-            },
-            onDidTriggerItemButton: (context) => {
-                preferencesService.openSettings({ query: context.item.audioCue.settingsKey });
-            },
-            placeHolder: ( (localize('audioCues.help.placeholder', 'Select an audio cue to play'))),
-        });
-        await quickPick;
-    }
-}
-ShowAudioCueHelp.ID = 'audioCues.help';
-let AudioCueLineDebuggerContribution = class AudioCueLineDebuggerContribution extends Disposable {
-    constructor(debugService, audioCueService) {
-        super();
-        this.audioCueService = audioCueService;
-        const isEnabled = observableFromEvent(audioCueService.onEnabledChanged(AudioCue$1.onDebugBreak), () => audioCueService.isEnabled(AudioCue$1.onDebugBreak));
-        this._register(autorunWithStore((reader, store) => {
-            if (!isEnabled.read(reader)) {
-                return;
-            }
-            const sessionDisposables = ( (new Map()));
-            store.add(toDisposable(() => {
-                sessionDisposables.forEach(d => d.dispose());
-                sessionDisposables.clear();
-            }));
-            store.add(debugService.onDidNewSession((session) => sessionDisposables.set(session, this.handleSession(session))));
-            store.add(debugService.onDidEndSession(session => {
-                sessionDisposables.get(session)?.dispose();
-                sessionDisposables.delete(session);
-            }));
-            debugService
-                .getModel()
-                .getSessions()
-                .forEach((session) => sessionDisposables.set(session, this.handleSession(session)));
-        }, 'subscribe to debug sessions'));
-    }
-    handleSession(session) {
-        return session.onDidChangeState(e => {
-            const stoppedDetails = session.getStoppedDetails();
-            const BREAKPOINT_STOP_REASON = 'breakpoint';
-            if (stoppedDetails && stoppedDetails.reason === BREAKPOINT_STOP_REASON) {
-                this.audioCueService.playAudioCue(AudioCue$1.onDebugBreak);
-            }
-        });
-    }
-};
-AudioCueLineDebuggerContribution = ( (__decorate([
-    ( (__param(0, IDebugService))),
-    ( (__param(1, IAudioCueService)))
-], AudioCueLineDebuggerContribution)));
 let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution extends Disposable {
     constructor(editorService, instantiationService, audioCueService, _configurationService) {
         super();
@@ -851,7 +772,7 @@ let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution exte
         });
         const debouncedPosition = debouncedObservable(curPosition, this._configurationService.getValue('audioCues.debouncePositionChanges') ? 300 : 0, store);
         const isTyping = wasEventTriggeredRecently(editorModel.onDidChangeContent.bind(editorModel), 1000, store);
-        const featureStates = this.features.map((feature) => {
+        const featureStates = ( (this.features.map((feature) => {
             const lineFeatureState = feature.getObservableState(editor, editorModel);
             const isFeaturePresent = derived(`isPresentInLine:${feature.audioCue.name}`, (reader) => {
                 if (!this.isEnabledCache.get(feature.audioCue).read(reader)) {
@@ -866,18 +787,18 @@ let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution exte
             return derived(`typingDebouncedFeatureState:\n${feature.audioCue.name}`, (reader) => feature.debounceWhileTyping && isTyping.read(reader)
                 ? (debouncedPosition.read(reader), isFeaturePresent.get())
                 : isFeaturePresent.read(reader));
-        });
+        })));
         const state = derived('states', (reader) => ({
             lineNumber: debouncedPosition.read(reader),
-            featureStates: ( (new Map(this.features.map((feature, idx) => [
+            featureStates: ( (new Map( (this.features.map((feature, idx) => [
                 feature,
                 featureStates[idx].read(reader),
-            ])))),
+            ]))))),
         }));
         store.add(autorunDelta('Play Audio Cue', state, ({ lastValue, newValue }) => {
             const newFeatures = this.features.filter(feature => newValue?.featureStates.get(feature) &&
                 (!lastValue?.featureStates?.get(feature) || newValue.lineNumber !== lastValue.lineNumber));
-            this.audioCueService.playAudioCues(newFeatures.map(f => f.audioCue));
+            this.audioCueService.playAudioCues(( (newFeatures.map(f => f.audioCue))));
         }));
     }
 };
@@ -926,16 +847,18 @@ class FoldedAreaLineFeature {
             });
         }
         const foldingModel = observableFromPromise(foldingController.getFoldingModel() ?? Promise.resolve(undefined));
-        return foldingModel.map((v) => ({
-            isPresent: (position) => {
-                const regionAtLine = v.value?.getRegionAtLine(position.lineNumber);
-                const hasFolding = !regionAtLine
-                    ? false
-                    : regionAtLine.isCollapsed &&
-                        regionAtLine.startLineNumber === position.lineNumber;
-                return hasFolding;
-            },
-        }));
+        return (
+             (foldingModel.map((v) => ({
+                isPresent: (position) => {
+                    const regionAtLine = v.value?.getRegionAtLine(position.lineNumber);
+                    const hasFolding = !regionAtLine
+                        ? false
+                        : regionAtLine.isCollapsed &&
+                            regionAtLine.startLineNumber === position.lineNumber;
+                    return hasFolding;
+                },
+            })))
+        );
     }
 }
 let BreakpointLineFeature = class BreakpointLineFeature {
@@ -969,9 +892,9 @@ class InlineCompletionLineFeature {
                 isPresent: () => false,
             });
         }
-        const activeGhostText = observableFromEvent(ghostTextController.onActiveModelDidChange, () =>  ghostTextController.activeModel).map((activeModel) => (activeModel
+        const activeGhostText = ( (observableFromEvent(ghostTextController.onActiveModelDidChange, () =>  ghostTextController.activeModel).map((activeModel) => (activeModel
             ? observableFromEvent(activeModel.inlineCompletionsModel.onDidChange, () =>  activeModel.inlineCompletionsModel.ghostText)
-            : undefined));
+            : undefined))));
         return derived('ghostText', reader => {
             const ghostText = activeGhostText.read(reader)?.read(reader);
             return {
@@ -982,6 +905,85 @@ class InlineCompletionLineFeature {
         });
     }
 }
+let AudioCueLineDebuggerContribution = class AudioCueLineDebuggerContribution extends Disposable {
+    constructor(debugService, audioCueService) {
+        super();
+        this.audioCueService = audioCueService;
+        const isEnabled = observableFromEvent(audioCueService.onEnabledChanged(AudioCue$1.onDebugBreak), () => audioCueService.isEnabled(AudioCue$1.onDebugBreak));
+        this._register(autorunWithStore((reader, store) => {
+            if (!isEnabled.read(reader)) {
+                return;
+            }
+            const sessionDisposables = ( (new Map()));
+            store.add(toDisposable(() => {
+                sessionDisposables.forEach(d => d.dispose());
+                sessionDisposables.clear();
+            }));
+            store.add(debugService.onDidNewSession((session) => sessionDisposables.set(session, this.handleSession(session))));
+            store.add(debugService.onDidEndSession(session => {
+                sessionDisposables.get(session)?.dispose();
+                sessionDisposables.delete(session);
+            }));
+            debugService
+                .getModel()
+                .getSessions()
+                .forEach((session) => sessionDisposables.set(session, this.handleSession(session)));
+        }, 'subscribe to debug sessions'));
+    }
+    handleSession(session) {
+        return session.onDidChangeState(e => {
+            const stoppedDetails = session.getStoppedDetails();
+            const BREAKPOINT_STOP_REASON = 'breakpoint';
+            if (stoppedDetails && stoppedDetails.reason === BREAKPOINT_STOP_REASON) {
+                this.audioCueService.playAudioCue(AudioCue$1.onDebugBreak);
+            }
+        });
+    }
+};
+AudioCueLineDebuggerContribution = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IAudioCueService)))
+], AudioCueLineDebuggerContribution)));
+class ShowAudioCueHelp extends Action2 {
+    constructor() {
+        super({
+            id: ShowAudioCueHelp.ID,
+            title: {
+                value: ( (localize('audioCues.help', "Help: List Audio Cues"))),
+                original: 'Help: List Audio Cues'
+            },
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const audioCueService = accessor.get(IAudioCueService);
+        const quickPickService = accessor.get(IQuickInputService);
+        const preferencesService = accessor.get(IPreferencesService);
+        const accessibilityService = accessor.get(IAccessibilityService);
+        const items = ( (AudioCue$1.allAudioCues.map((cue, idx) => ({
+            label: accessibilityService.isScreenReaderOptimized() ?
+                `${cue.name}${audioCueService.isEnabled(cue) ? '' : ' (' + ( ( localize('disabled', "Disabled"))) + ')'}`
+                : `${audioCueService.isEnabled(cue) ? '$(check)' : '     '} ${cue.name}`,
+            audioCue: cue,
+            buttons: [{
+                    iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                    tooltip: ( (localize('audioCues.help.settings', 'Enable/Disable Audio Cue'))),
+                }],
+        }))));
+        const quickPick = quickPickService.pick(items, {
+            activeItem: items[0],
+            onDidFocus: (item) => {
+                audioCueService.playSound(item.audioCue.sound, true);
+            },
+            onDidTriggerItemButton: (context) => {
+                preferencesService.openSettings({ query: context.item.audioCue.settingsKey });
+            },
+            placeHolder: ( (localize('audioCues.help.placeholder', 'Select an audio cue to play'))),
+        });
+        await quickPick;
+    }
+}
+ShowAudioCueHelp.ID = 'audioCues.help';
 const audioCueFeatureBase = {
     'type': 'string',
     'enum': ['auto', 'on', 'off'],

package/dist/button.js

@@ -1,4 +1,4 @@
-import { E as Emitter } from './contextkey.js';
+import { E as Emitter } from './services2.js';
 import { n } from './polyfill.js';
 import { addDisposableListener, EventType, EventHelper, trackFocus, reset } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';

package/dist/cancellation.js

@@ -0,0 +1,3 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+const CancellationTokenSource = monaco.CancellationTokenSource;
+export { CancellationTokenSource as C };