@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/browser/parts/statusbar/statusbarItem.js

@@ -0,0 +1,250 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { toErrorMessage } from '../../../../base/common/errorMessage.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { SimpleIconLabel } from '../../../../base/browser/ui/iconLabel/simpleIconLabel.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { ShowTooltipCommand, StatusbarEntryKinds } from '../../../services/statusbar/browser/statusbar.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { isThemeColor } from '../../../../editor/common/editorCommon.js';
+import { show, hide, addDisposableListener, EventHelper, EventType, append } from '../../../../base/browser/dom.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { assertIsDefined } from '../../../../base/common/types.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { renderIcon, renderLabelWithIcons } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { syncing, spinningLoading } from '../../../../platform/theme/common/iconRegistry.js';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { isMarkdownString, markdownStringEqual } from '../../../../base/common/htmlContent.js';
+import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
+let StatusbarEntryItem = class StatusbarEntryItem extends Disposable {
+    get name() {
+        return assertIsDefined(this.entry).name;
+    }
+    get hasCommand() {
+        return typeof this.entry?.command !== 'undefined';
+    }
+    constructor(container, entry, hoverDelegate, commandService, notificationService, telemetryService, themeService) {
+        super();
+        this.container = container;
+        this.hoverDelegate = hoverDelegate;
+        this.commandService = commandService;
+        this.notificationService = notificationService;
+        this.telemetryService = telemetryService;
+        this.themeService = themeService;
+        this.entry = undefined;
+        this.foregroundListener = this._register(( new MutableDisposable()));
+        this.backgroundListener = this._register(( new MutableDisposable()));
+        this.commandMouseListener = this._register(( new MutableDisposable()));
+        this.commandTouchListener = this._register(( new MutableDisposable()));
+        this.commandKeyboardListener = this._register(( new MutableDisposable()));
+        this.focusListener = this._register(( new MutableDisposable()));
+        this.focusOutListener = this._register(( new MutableDisposable()));
+        this.hover = undefined;
+        this.labelContainer = document.createElement('a');
+        this.labelContainer.tabIndex = -1;
+        this.labelContainer.setAttribute('role', 'button');
+        this.labelContainer.className = 'statusbar-item-label';
+        this._register(Gesture.addTarget(this.labelContainer));
+        this.label = this._register(( new StatusBarCodiconLabel(this.labelContainer)));
+        this.container.appendChild(this.labelContainer);
+        this.beakContainer = document.createElement('div');
+        this.beakContainer.className = 'status-bar-item-beak-container';
+        this.container.appendChild(this.beakContainer);
+        this.update(entry);
+    }
+    update(entry) {
+        this.label.showProgress = entry.showProgress ?? false;
+        if (!this.entry || entry.text !== this.entry.text) {
+            this.label.text = entry.text;
+            if (entry.text) {
+                show(this.labelContainer);
+            }
+            else {
+                hide(this.labelContainer);
+            }
+        }
+        if (!this.entry || entry.ariaLabel !== this.entry.ariaLabel) {
+            this.container.setAttribute('aria-label', entry.ariaLabel);
+            this.labelContainer.setAttribute('aria-label', entry.ariaLabel);
+        }
+        if (!this.entry || entry.role !== this.entry.role) {
+            this.labelContainer.setAttribute('role', entry.role || 'button');
+        }
+        if (!this.entry || !this.isEqualTooltip(this.entry, entry)) {
+            const hoverContents = isMarkdownString(entry.tooltip) ? { markdown: entry.tooltip, markdownNotSupportedFallback: undefined } : entry.tooltip;
+            if (this.hover) {
+                this.hover.update(hoverContents);
+            }
+            else {
+                this.hover = this._register(setupCustomHover(this.hoverDelegate, this.container, hoverContents));
+            }
+            if (entry.command !== ShowTooltipCommand ) {
+                this.focusListener.value = addDisposableListener(this.labelContainer, EventType.FOCUS, e => {
+                    EventHelper.stop(e);
+                    this.hover?.show(false);
+                });
+                this.focusOutListener.value = addDisposableListener(this.labelContainer, EventType.FOCUS_OUT, e => {
+                    EventHelper.stop(e);
+                    this.hover?.hide();
+                });
+            }
+        }
+        if (!this.entry || entry.command !== this.entry.command) {
+            this.commandMouseListener.clear();
+            this.commandTouchListener.clear();
+            this.commandKeyboardListener.clear();
+            const command = entry.command;
+            if (command && (command !== ShowTooltipCommand || this.hover) ) {
+                this.commandMouseListener.value = addDisposableListener(this.labelContainer, EventType.CLICK, () => this.executeCommand(command));
+                this.commandTouchListener.value = addDisposableListener(this.labelContainer, EventType$1.Tap, () => this.executeCommand(command));
+                this.commandKeyboardListener.value = addDisposableListener(this.labelContainer, EventType.KEY_DOWN, e => {
+                    const event = ( new StandardKeyboardEvent(e));
+                    if (event.equals(10 ) || event.equals(3 )) {
+                        EventHelper.stop(e);
+                        this.executeCommand(command);
+                    }
+                    else if (event.equals(9 ) || event.equals(15 ) || event.equals(17 )) {
+                        EventHelper.stop(e);
+                        this.hover?.hide();
+                    }
+                });
+                this.labelContainer.classList.remove('disabled');
+            }
+            else {
+                this.labelContainer.classList.add('disabled');
+            }
+        }
+        if (!this.entry || entry.showBeak !== this.entry.showBeak) {
+            if (entry.showBeak) {
+                this.container.classList.add('has-beak');
+            }
+            else {
+                this.container.classList.remove('has-beak');
+            }
+        }
+        const hasBackgroundColor = !!entry.backgroundColor || (entry.kind && entry.kind !== 'standard');
+        if (!this.entry || entry.kind !== this.entry.kind) {
+            for (const kind of StatusbarEntryKinds) {
+                this.container.classList.remove(`${kind}-kind`);
+            }
+            if (entry.kind && entry.kind !== 'standard') {
+                this.container.classList.add(`${entry.kind}-kind`);
+            }
+            this.container.classList.toggle('has-background-color', hasBackgroundColor);
+        }
+        if (!this.entry || entry.color !== this.entry.color) {
+            this.applyColor(this.labelContainer, entry.color);
+        }
+        if (!this.entry || entry.backgroundColor !== this.entry.backgroundColor) {
+            this.container.classList.toggle('has-background-color', hasBackgroundColor);
+            this.applyColor(this.container, entry.backgroundColor, true);
+        }
+        this.entry = entry;
+    }
+    isEqualTooltip({ tooltip }, { tooltip: otherTooltip }) {
+        if (tooltip === undefined) {
+            return otherTooltip === undefined;
+        }
+        if (isMarkdownString(tooltip)) {
+            return isMarkdownString(otherTooltip) && markdownStringEqual(tooltip, otherTooltip);
+        }
+        return tooltip === otherTooltip;
+    }
+    async executeCommand(command) {
+        if (command === ShowTooltipCommand) {
+            this.hover?.show(true );
+        }
+        else {
+            const id = typeof command === 'string' ? command : command.id;
+            const args = typeof command === 'string' ? [] : command.arguments ?? [];
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id, from: 'status bar' });
+            try {
+                await this.commandService.executeCommand(id, ...args);
+            }
+            catch (error) {
+                this.notificationService.error(toErrorMessage(error));
+            }
+        }
+    }
+    applyColor(container, color, isBackground) {
+        let colorResult = undefined;
+        if (isBackground) {
+            this.backgroundListener.clear();
+        }
+        else {
+            this.foregroundListener.clear();
+        }
+        if (color) {
+            if (isThemeColor(color)) {
+                colorResult = this.themeService.getColorTheme().getColor(color.id)?.toString();
+                const listener = this.themeService.onDidColorThemeChange(theme => {
+                    const colorValue = theme.getColor(color.id)?.toString();
+                    if (isBackground) {
+                        container.style.backgroundColor = colorValue ?? '';
+                    }
+                    else {
+                        container.style.color = colorValue ?? '';
+                    }
+                });
+                if (isBackground) {
+                    this.backgroundListener.value = listener;
+                }
+                else {
+                    this.foregroundListener.value = listener;
+                }
+            }
+            else {
+                colorResult = color;
+            }
+        }
+        if (isBackground) {
+            container.style.backgroundColor = colorResult ?? '';
+        }
+        else {
+            container.style.color = colorResult ?? '';
+        }
+    }
+};
+StatusbarEntryItem = ( __decorate([
+    ( __param(3, ICommandService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, ITelemetryService)),
+    ( __param(6, IThemeService))
+], StatusbarEntryItem));
+class StatusBarCodiconLabel extends SimpleIconLabel {
+    constructor(container) {
+        super(container);
+        this.container = container;
+        this.progressCodicon = renderIcon(syncing);
+        this.currentText = '';
+        this.currentShowProgress = false;
+    }
+    set showProgress(showProgress) {
+        if (this.currentShowProgress !== showProgress) {
+            this.currentShowProgress = showProgress;
+            this.progressCodicon = renderIcon(showProgress === 'loading' ? spinningLoading : syncing);
+            this.text = this.currentText;
+        }
+    }
+    set text(text) {
+        if (this.currentShowProgress) {
+            if (this.container.firstChild !== this.progressCodicon) {
+                this.container.appendChild(this.progressCodicon);
+            }
+            for (const node of Array.from(this.container.childNodes)) {
+                if (node !== this.progressCodicon) {
+                    node.remove();
+                }
+            }
+            let textContent = text ?? '';
+            if (textContent) {
+                textContent = ` ${textContent}`;
+            }
+            append(this.container, ...renderLabelWithIcons(textContent));
+        }
+        else {
+            super.text = text;
+        }
+    }
+}
+export { StatusbarEntryItem };

package/vscode/src/vs/workbench/browser/parts/statusbar/statusbarModel.js

@@ -0,0 +1,249 @@
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { isStatusbarEntryLocation } from '../../../services/statusbar/browser/statusbar.js';
+import { isAncestorOfActiveElement, hide, show } from '../../../../base/browser/dom.js';
+import { Emitter } from '../../../../base/common/event.js';
+class StatusbarViewModel extends Disposable {
+    static { this.HIDDEN_ENTRIES_KEY = 'workbench.statusbar.hidden'; }
+    get entries() { return this._entries.slice(0); }
+    get lastFocusedEntry() {
+        return this._lastFocusedEntry && !this.isHidden(this._lastFocusedEntry.id) ? this._lastFocusedEntry : undefined;
+    }
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this._onDidChangeEntryVisibility = this._register(( new Emitter()));
+        this.onDidChangeEntryVisibility = this._onDidChangeEntryVisibility.event;
+        this._entries = [];
+        this.hidden = ( new Set());
+        this.restoreState();
+        this.registerListeners();
+    }
+    restoreState() {
+        const hiddenRaw = this.storageService.get(StatusbarViewModel.HIDDEN_ENTRIES_KEY, 0 );
+        if (hiddenRaw) {
+            try {
+                const hiddenArray = JSON.parse(hiddenRaw);
+                this.hidden = ( new Set(hiddenArray.filter(entry => !entry.startsWith('status.workspaceTrust.'))));
+            }
+            catch (error) {
+            }
+        }
+    }
+    registerListeners() {
+        this._register(this.storageService.onDidChangeValue(0 , StatusbarViewModel.HIDDEN_ENTRIES_KEY, this._register(( new DisposableStore())))(() => this.onDidStorageValueChange()));
+    }
+    onDidStorageValueChange() {
+        const currentlyHidden = ( new Set(this.hidden));
+        this.hidden.clear();
+        this.restoreState();
+        const changed = ( new Set());
+        for (const id of currentlyHidden) {
+            if (!( this.hidden.has(id))) {
+                changed.add(id);
+            }
+        }
+        for (const id of this.hidden) {
+            if (!( currentlyHidden.has(id))) {
+                changed.add(id);
+            }
+        }
+        if (changed.size > 0) {
+            for (const entry of this._entries) {
+                if (( changed.has(entry.id))) {
+                    this.updateVisibility(entry.id, true);
+                    changed.delete(entry.id);
+                }
+            }
+        }
+    }
+    add(entry) {
+        this._entries.push(entry);
+        this.updateVisibility(entry, false);
+        this.sort();
+        this.markFirstLastVisibleEntry();
+    }
+    remove(entry) {
+        const index = this._entries.indexOf(entry);
+        if (index >= 0) {
+            this._entries.splice(index, 1);
+            if (( this._entries.some(
+                otherEntry => isStatusbarEntryLocation(otherEntry.priority.primary) && otherEntry.priority.primary.id === entry.id
+            ))) {
+                this.sort();
+            }
+            this.markFirstLastVisibleEntry();
+        }
+    }
+    isHidden(id) {
+        return ( this.hidden.has(id));
+    }
+    hide(id) {
+        if (!( this.hidden.has(id))) {
+            this.hidden.add(id);
+            this.updateVisibility(id, true);
+            this.saveState();
+        }
+    }
+    show(id) {
+        if (( this.hidden.has(id))) {
+            this.hidden.delete(id);
+            this.updateVisibility(id, true);
+            this.saveState();
+        }
+    }
+    findEntry(container) {
+        return this._entries.find(entry => entry.container === container);
+    }
+    getEntries(alignment) {
+        return this._entries.filter(entry => entry.alignment === alignment);
+    }
+    focusNextEntry() {
+        this.focusEntry(+1, 0);
+    }
+    focusPreviousEntry() {
+        this.focusEntry(-1, this.entries.length - 1);
+    }
+    isEntryFocused() {
+        return !!this.getFocusedEntry();
+    }
+    getFocusedEntry() {
+        return this._entries.find(entry => isAncestorOfActiveElement(entry.container));
+    }
+    focusEntry(delta, restartPosition) {
+        const getVisibleEntry = (start) => {
+            let indexToFocus = start;
+            let entry = (indexToFocus >= 0 && indexToFocus < this._entries.length) ? this._entries[indexToFocus] : undefined;
+            while (entry && this.isHidden(entry.id)) {
+                indexToFocus += delta;
+                entry = (indexToFocus >= 0 && indexToFocus < this._entries.length) ? this._entries[indexToFocus] : undefined;
+            }
+            return entry;
+        };
+        const focused = this.getFocusedEntry();
+        if (focused) {
+            const entry = getVisibleEntry(this._entries.indexOf(focused) + delta);
+            if (entry) {
+                this._lastFocusedEntry = entry;
+                entry.labelContainer.focus();
+                return;
+            }
+        }
+        const entry = getVisibleEntry(restartPosition);
+        if (entry) {
+            this._lastFocusedEntry = entry;
+            entry.labelContainer.focus();
+        }
+    }
+    updateVisibility(arg1, trigger) {
+        if (typeof arg1 === 'string') {
+            const id = arg1;
+            for (const entry of this._entries) {
+                if (entry.id === id) {
+                    this.updateVisibility(entry, trigger);
+                }
+            }
+        }
+        else {
+            const entry = arg1;
+            const isHidden = this.isHidden(entry.id);
+            if (isHidden) {
+                hide(entry.container);
+            }
+            else {
+                show(entry.container);
+            }
+            if (trigger) {
+                this._onDidChangeEntryVisibility.fire({ id: entry.id, visible: !isHidden });
+            }
+            this.markFirstLastVisibleEntry();
+        }
+    }
+    saveState() {
+        if (this.hidden.size > 0) {
+            this.storageService.store(StatusbarViewModel.HIDDEN_ENTRIES_KEY, JSON.stringify(Array.from(( this.hidden.values()))), 0 , 0 );
+        }
+        else {
+            this.storageService.remove(StatusbarViewModel.HIDDEN_ENTRIES_KEY, 0 );
+        }
+    }
+    sort() {
+        const mapEntryWithNumberedPriorityToIndex = ( new Map());
+        const mapEntryWithRelativePriority = ( new Map());
+        for (let i = 0; i < this._entries.length; i++) {
+            const entry = this._entries[i];
+            if (typeof entry.priority.primary === 'number') {
+                mapEntryWithNumberedPriorityToIndex.set(entry, i);
+            }
+            else {
+                let entries = mapEntryWithRelativePriority.get(entry.priority.primary.id);
+                if (!entries) {
+                    entries = [];
+                    mapEntryWithRelativePriority.set(entry.priority.primary.id, entries);
+                }
+                entries.push(entry);
+            }
+        }
+        const sortedEntriesWithNumberedPriority = Array.from(( mapEntryWithNumberedPriorityToIndex.keys()));
+        sortedEntriesWithNumberedPriority.sort((entryA, entryB) => {
+            if (entryA.alignment === entryB.alignment) {
+                if (entryA.priority.primary !== entryB.priority.primary) {
+                    return Number(entryB.priority.primary) - Number(entryA.priority.primary);
+                }
+                if (entryA.priority.secondary !== entryB.priority.secondary) {
+                    return entryB.priority.secondary - entryA.priority.secondary;
+                }
+                return mapEntryWithNumberedPriorityToIndex.get(entryA) - mapEntryWithNumberedPriorityToIndex.get(entryB);
+            }
+            if (entryA.alignment === 0 ) {
+                return -1;
+            }
+            if (entryB.alignment === 0 ) {
+                return 1;
+            }
+            return 0;
+        });
+        let sortedEntries;
+        if (mapEntryWithRelativePriority.size > 0) {
+            sortedEntries = [];
+            for (const entry of sortedEntriesWithNumberedPriority) {
+                const relativeEntries = mapEntryWithRelativePriority.get(entry.id);
+                if (relativeEntries) {
+                    sortedEntries.push(...relativeEntries.filter(entry => isStatusbarEntryLocation(entry.priority.primary) && entry.priority.primary.alignment === 0 ));
+                }
+                sortedEntries.push(entry);
+                if (relativeEntries) {
+                    sortedEntries.push(...relativeEntries.filter(entry => isStatusbarEntryLocation(entry.priority.primary) && entry.priority.primary.alignment === 1 ));
+                }
+                mapEntryWithRelativePriority.delete(entry.id);
+            }
+            for (const [, entries] of mapEntryWithRelativePriority) {
+                sortedEntries.push(...entries);
+            }
+        }
+        else {
+            sortedEntries = sortedEntriesWithNumberedPriority;
+        }
+        this._entries = sortedEntries;
+    }
+    markFirstLastVisibleEntry() {
+        this.doMarkFirstLastVisibleStatusbarItem(this.getEntries(0 ));
+        this.doMarkFirstLastVisibleStatusbarItem(this.getEntries(1 ));
+    }
+    doMarkFirstLastVisibleStatusbarItem(entries) {
+        let firstVisibleItem;
+        let lastVisibleItem;
+        for (const entry of entries) {
+            entry.container.classList.remove('first-visible-item', 'last-visible-item');
+            const isVisible = !this.isHidden(entry.id);
+            if (isVisible) {
+                if (!firstVisibleItem) {
+                    firstVisibleItem = entry;
+                }
+                lastVisibleItem = entry;
+            }
+        }
+        firstVisibleItem?.container.classList.add('first-visible-item');
+        lastVisibleItem?.container.classList.add('last-visible-item');
+    }
+}
+export { StatusbarViewModel };