@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/browser/parts/compositeBarActions.js

@@ -0,0 +1,578 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Action, Separator } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { addDisposableListener, EventType, append, $, hide, clearNode, show, EventHelper, getDomNodePagePosition } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { MutableDisposable, DisposableStore, toDisposable, disposeIfDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { NumberBadge, TextBadge, IconBadge, ProgressBadge } from '../../services/activity/common/activity.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { contrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { DelayedDragHandler } from 'monaco-editor/esm/vs/base/browser/dnd.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { CompositeDragAndDropObserver, toggleDropEffect } from '../dnd.js';
+import { BaseActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IHoverService } from '../../services/hover/browser/hover.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+class ActivityAction extends Action {
+    constructor(_activity) {
+        super(_activity.id, _activity.name, _activity.classNames?.join(' '), true);
+        this._activity = _activity;
+        this._onDidChangeActivity = this._register(( new Emitter()));
+        this.onDidChangeActivity = this._onDidChangeActivity.event;
+        this._onDidChangeBadge = this._register(( new Emitter()));
+        this.onDidChangeBadge = this._onDidChangeBadge.event;
+    }
+    get activity() {
+        return this._activity;
+    }
+    set activity(activity) {
+        this._label = activity.name;
+        this._activity = activity;
+        this._onDidChangeActivity.fire(this);
+    }
+    activate() {
+        if (!this.checked) {
+            this._setChecked(true);
+        }
+    }
+    deactivate() {
+        if (this.checked) {
+            this._setChecked(false);
+        }
+    }
+    getBadge() {
+        return this.badge;
+    }
+    getClass() {
+        return this.clazz;
+    }
+    setBadge(badge, clazz) {
+        this.badge = badge;
+        this.clazz = clazz;
+        this._onDidChangeBadge.fire(this);
+    }
+    dispose() {
+        this._onDidChangeActivity.dispose();
+        this._onDidChangeBadge.dispose();
+        super.dispose();
+    }
+}
+let ActivityActionViewItem = class ActivityActionViewItem extends BaseActionViewItem {
+    constructor(action, options, badgesEnabled, themeService, hoverService, configurationService, keybindingService) {
+        super(null, action, options);
+        this.badgesEnabled = badgesEnabled;
+        this.themeService = themeService;
+        this.hoverService = hoverService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.badgeDisposable = this._register(( new MutableDisposable()));
+        this.hoverDisposables = this._register(( new DisposableStore()));
+        this.showHoverScheduler = ( new RunOnceScheduler(() => this.showHover(), 0));
+        this.options = options;
+        this._register(this.themeService.onDidColorThemeChange(this.onThemeChange, this));
+        this._register(action.onDidChangeActivity(this.updateActivity, this));
+        this._register(Event.filter(keybindingService.onDidUpdateKeybindings, () => this.keybindingLabel !== this.computeKeybindingLabel())(() => this.updateTitle()));
+        this._register(action.onDidChangeBadge(this.updateBadge, this));
+        this._register(toDisposable(() => this.showHoverScheduler.cancel()));
+    }
+    get activity() {
+        return this._action.activity;
+    }
+    updateStyles() {
+        const theme = this.themeService.getColorTheme();
+        const colors = this.options.colors(theme);
+        if (this.label) {
+            if (this.options.icon) {
+                const foreground = this._action.checked ? colors.activeForegroundColor : colors.inactiveForegroundColor;
+                if (this.activity.iconUrl) {
+                    this.label.style.backgroundColor = foreground ? ( foreground.toString()) : '';
+                    this.label.style.color = '';
+                }
+                else {
+                    this.label.style.color = foreground ? ( foreground.toString()) : '';
+                    this.label.style.backgroundColor = '';
+                }
+            }
+            else {
+                const foreground = this._action.checked ? colors.activeForegroundColor : colors.inactiveForegroundColor;
+                const borderBottomColor = this._action.checked ? colors.activeBorderBottomColor : null;
+                this.label.style.color = foreground ? ( foreground.toString()) : '';
+                this.label.style.borderBottomColor = borderBottomColor ? ( borderBottomColor.toString()) : '';
+            }
+            this.container.style.setProperty('--insert-border-color', colors.dragAndDropBorder ? ( colors.dragAndDropBorder.toString()) : '');
+        }
+        if (this.badgeContent) {
+            const badgeForeground = colors.badgeForeground;
+            const badgeBackground = colors.badgeBackground;
+            const contrastBorderColor = theme.getColor(contrastBorder);
+            this.badgeContent.style.color = badgeForeground ? ( badgeForeground.toString()) : '';
+            this.badgeContent.style.backgroundColor = badgeBackground ? ( badgeBackground.toString()) : '';
+            this.badgeContent.style.borderStyle = contrastBorderColor ? 'solid' : '';
+            this.badgeContent.style.borderWidth = contrastBorderColor ? '1px' : '';
+            this.badgeContent.style.borderColor = contrastBorderColor ? ( contrastBorderColor.toString()) : '';
+        }
+    }
+    render(container) {
+        super.render(container);
+        this.container = container;
+        if (this.options.icon) {
+            this.container.classList.add('icon');
+        }
+        if (this.options.hasPopup) {
+            this.container.setAttribute('role', 'button');
+            this.container.setAttribute('aria-haspopup', 'true');
+        }
+        else {
+            this.container.setAttribute('role', 'tab');
+        }
+        this._register(addDisposableListener(this.container, EventType.MOUSE_DOWN, () => {
+            this.container.classList.add('clicked');
+        }));
+        this._register(addDisposableListener(this.container, EventType.MOUSE_UP, () => {
+            if (this.mouseUpTimeout) {
+                clearTimeout(this.mouseUpTimeout);
+            }
+            this.mouseUpTimeout = setTimeout(() => {
+                this.container.classList.remove('clicked');
+            }, 800);
+        }));
+        this.label = append(container, $('a'));
+        this.badge = append(container, $('.badge'));
+        this.badgeContent = append(this.badge, $('.badge-content'));
+        append(container, $('.active-item-indicator'));
+        hide(this.badge);
+        this.updateActivity();
+        this.updateStyles();
+        this.updateHover();
+    }
+    onThemeChange(theme) {
+        this.updateStyles();
+    }
+    updateActivity() {
+        this.updateLabel();
+        this.updateTitle();
+        this.updateBadge();
+        this.updateStyles();
+    }
+    updateBadge() {
+        const action = this.action;
+        if (!this.badge || !this.badgeContent || !(action instanceof ActivityAction)) {
+            return;
+        }
+        const badge = action.getBadge();
+        const clazz = action.getClass();
+        this.badgeDisposable.clear();
+        clearNode(this.badgeContent);
+        hide(this.badge);
+        const shouldRenderBadges = this.badgesEnabled(this.activity.id);
+        if (badge && shouldRenderBadges) {
+            if (badge instanceof NumberBadge) {
+                if (badge.number) {
+                    let number = ( badge.number.toString());
+                    if (badge.number > 999) {
+                        const noOfThousands = badge.number / 1000;
+                        const floor = Math.floor(noOfThousands);
+                        if (noOfThousands > floor) {
+                            number = `${floor}K+`;
+                        }
+                        else {
+                            number = `${noOfThousands}K`;
+                        }
+                    }
+                    this.badgeContent.textContent = number;
+                    show(this.badge);
+                }
+            }
+            else if (badge instanceof TextBadge) {
+                this.badgeContent.textContent = badge.text;
+                show(this.badge);
+            }
+            else if (badge instanceof IconBadge) {
+                const clazzList = ThemeIcon.asClassNameArray(badge.icon);
+                this.badgeContent.classList.add(...clazzList);
+                show(this.badge);
+            }
+            else if (badge instanceof ProgressBadge) {
+                show(this.badge);
+            }
+            if (clazz) {
+                const classNames = clazz.split(' ');
+                this.badge.classList.add(...classNames);
+                this.badgeDisposable.value = toDisposable(() => this.badge.classList.remove(...classNames));
+            }
+        }
+        this.updateTitle();
+    }
+    updateLabel() {
+        this.label.className = 'action-label';
+        if (this.activity.classNames) {
+            this.label.classList.add(...this.activity.classNames);
+        }
+        if (!this.options.icon) {
+            this.label.textContent = this.action.label;
+        }
+    }
+    updateTitle() {
+        const title = this.computeTitle();
+        [this.label, this.badge, this.container].forEach(element => {
+            if (element) {
+                element.setAttribute('aria-label', title);
+                element.setAttribute('title', '');
+                element.removeAttribute('title');
+            }
+        });
+    }
+    computeTitle() {
+        this.keybindingLabel = this.computeKeybindingLabel();
+        let title = this.keybindingLabel ? ( localize('titleKeybinding', "{0} ({1})", this.activity.name, this.keybindingLabel)) : this.activity.name;
+        const badge = this.action.getBadge();
+        if (badge?.getDescription()) {
+            title = ( localize('badgeTitle', "{0} - {1}", title, badge.getDescription()));
+        }
+        return title;
+    }
+    computeKeybindingLabel() {
+        const keybinding = this.activity.keybindingId ? this.keybindingService.lookupKeybinding(this.activity.keybindingId) : null;
+        return keybinding?.getLabel();
+    }
+    updateHover() {
+        this.hoverDisposables.clear();
+        this.updateTitle();
+        this.hoverDisposables.add(addDisposableListener(this.container, EventType.MOUSE_OVER, () => {
+            if (!this.showHoverScheduler.isScheduled()) {
+                if (Date.now() - ActivityActionViewItem.hoverLeaveTime < 200) {
+                    this.showHover(true);
+                }
+                else {
+                    this.showHoverScheduler.schedule(this.configurationService.getValue('workbench.hover.delay'));
+                }
+            }
+        }, true));
+        this.hoverDisposables.add(addDisposableListener(this.container, EventType.MOUSE_LEAVE, e => {
+            if (e.target === this.container) {
+                ActivityActionViewItem.hoverLeaveTime = Date.now();
+                this.hoverService.hideHover();
+                this.showHoverScheduler.cancel();
+            }
+        }, true));
+        this.hoverDisposables.add(toDisposable(() => {
+            this.hoverService.hideHover();
+            this.showHoverScheduler.cancel();
+        }));
+    }
+    showHover(skipFadeInAnimation = false) {
+        if (this.lastHover && !this.lastHover.isDisposed) {
+            return;
+        }
+        const hoverPosition = this.options.hoverOptions.position();
+        this.lastHover = this.hoverService.showHover({
+            target: this.container,
+            hoverPosition,
+            content: this.computeTitle(),
+            showPointer: true,
+            compact: true,
+            hideOnKeyDown: true,
+            skipFadeInAnimation,
+        });
+    }
+    dispose() {
+        super.dispose();
+        if (this.mouseUpTimeout) {
+            clearTimeout(this.mouseUpTimeout);
+        }
+        this.badge.remove();
+    }
+};
+ActivityActionViewItem.hoverLeaveTime = 0;
+ActivityActionViewItem = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, IHoverService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IKeybindingService))
+], ActivityActionViewItem));
+class CompositeOverflowActivityAction extends ActivityAction {
+    constructor(showMenu) {
+        super({
+            id: 'additionalComposites.action',
+            name: ( localize('additionalViews', "Additional Views")),
+            classNames: ThemeIcon.asClassNameArray(Codicon.more)
+        });
+        this.showMenu = showMenu;
+    }
+    async run() {
+        this.showMenu();
+    }
+}
+let CompositeOverflowActivityActionViewItem = class CompositeOverflowActivityActionViewItem extends ActivityActionViewItem {
+    constructor(action, getOverflowingComposites, getActiveCompositeId, getBadge, getCompositeOpenAction, colors, hoverOptions, contextMenuService, themeService, hoverService, configurationService, keybindingService) {
+        super(action, { icon: true, colors, hasPopup: true, hoverOptions }, () => true, themeService, hoverService, configurationService, keybindingService);
+        this.getOverflowingComposites = getOverflowingComposites;
+        this.getActiveCompositeId = getActiveCompositeId;
+        this.getBadge = getBadge;
+        this.getCompositeOpenAction = getCompositeOpenAction;
+        this.contextMenuService = contextMenuService;
+        this.actions = [];
+    }
+    showMenu() {
+        if (this.actions) {
+            disposeIfDisposable(this.actions);
+        }
+        this.actions = this.getActions();
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => this.container,
+            getActions: () => this.actions,
+            getCheckedActionsRepresentation: () => 'radio',
+            onHide: () => disposeIfDisposable(this.actions)
+        });
+    }
+    getActions() {
+        return ( this.getOverflowingComposites().map(composite => {
+            const action = this.getCompositeOpenAction(composite.id);
+            action.checked = this.getActiveCompositeId() === action.id;
+            const badge = this.getBadge(composite.id);
+            let suffix;
+            if (badge instanceof NumberBadge) {
+                suffix = badge.number;
+            }
+            else if (badge instanceof TextBadge) {
+                suffix = badge.text;
+            }
+            if (suffix) {
+                action.label = ( localize('numberBadge', "{0} ({1})", composite.name, suffix));
+            }
+            else {
+                action.label = composite.name || '';
+            }
+            return action;
+        }));
+    }
+    dispose() {
+        super.dispose();
+        if (this.actions) {
+            this.actions = disposeIfDisposable(this.actions);
+        }
+    }
+};
+CompositeOverflowActivityActionViewItem = ( __decorate([
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, IHoverService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IKeybindingService))
+], CompositeOverflowActivityActionViewItem));
+let ManageExtensionAction = class ManageExtensionAction extends Action {
+    constructor(commandService) {
+        super('activitybar.manage.extension', ( localize('manageExtension', "Manage Extension")));
+        this.commandService = commandService;
+    }
+    run(id) {
+        return this.commandService.executeCommand('_extensions.manage', id);
+    }
+};
+ManageExtensionAction = ( __decorate([
+    ( __param(0, ICommandService))
+], ManageExtensionAction));
+let CompositeActionViewItem = class CompositeActionViewItem extends ActivityActionViewItem {
+    constructor(options, compositeActivityAction, toggleCompositePinnedAction, toggleCompositeBadgeAction, compositeContextMenuActionsProvider, contextMenuActionsProvider, dndHandler, compositeBar, contextMenuService, keybindingService, instantiationService, themeService, hoverService, configurationService) {
+        super(compositeActivityAction, options, compositeBar.areBadgesEnabled.bind(compositeBar), themeService, hoverService, configurationService, keybindingService);
+        this.compositeActivityAction = compositeActivityAction;
+        this.toggleCompositePinnedAction = toggleCompositePinnedAction;
+        this.toggleCompositeBadgeAction = toggleCompositeBadgeAction;
+        this.compositeContextMenuActionsProvider = compositeContextMenuActionsProvider;
+        this.contextMenuActionsProvider = contextMenuActionsProvider;
+        this.dndHandler = dndHandler;
+        this.compositeBar = compositeBar;
+        this.contextMenuService = contextMenuService;
+        if (!CompositeActionViewItem.manageExtensionAction) {
+            CompositeActionViewItem.manageExtensionAction = instantiationService.createInstance(ManageExtensionAction);
+        }
+    }
+    render(container) {
+        super.render(container);
+        this.updateChecked();
+        this.updateEnabled();
+        this._register(addDisposableListener(this.container, EventType.CONTEXT_MENU, e => {
+            EventHelper.stop(e, true);
+            this.showContextMenu(container);
+        }));
+        let insertDropBefore = undefined;
+        this._register(CompositeDragAndDropObserver.INSTANCE.registerDraggable(this.container, () => { return { type: 'composite', id: this.activity.id }; }, {
+            onDragOver: e => {
+                const isValidMove = e.dragAndDropData.getData().id !== this.activity.id && this.dndHandler.onDragOver(e.dragAndDropData, this.activity.id, e.eventData);
+                toggleDropEffect(e.eventData.dataTransfer, 'move', isValidMove);
+                insertDropBefore = this.updateFromDragging(container, isValidMove, e.eventData);
+            },
+            onDragLeave: e => {
+                insertDropBefore = this.updateFromDragging(container, false, e.eventData);
+            },
+            onDragEnd: e => {
+                insertDropBefore = this.updateFromDragging(container, false, e.eventData);
+            },
+            onDrop: e => {
+                EventHelper.stop(e.eventData, true);
+                this.dndHandler.drop(e.dragAndDropData, this.activity.id, e.eventData, insertDropBefore);
+                insertDropBefore = this.updateFromDragging(container, false, e.eventData);
+            },
+            onDragStart: e => {
+                if (e.dragAndDropData.getData().id !== this.activity.id) {
+                    return;
+                }
+                if (e.eventData.dataTransfer) {
+                    e.eventData.dataTransfer.effectAllowed = 'move';
+                }
+                this.blur();
+            }
+        }));
+        [this.badge, this.label].forEach(element => this._register(( new DelayedDragHandler(element, () => {
+            if (!this.action.checked) {
+                this.action.run();
+            }
+        }))));
+        this.updateStyles();
+    }
+    updateFromDragging(element, showFeedback, event) {
+        const rect = element.getBoundingClientRect();
+        const posX = event.clientX;
+        const posY = event.clientY;
+        const height = rect.bottom - rect.top;
+        const width = rect.right - rect.left;
+        const forceTop = posY <= rect.top + height * 0.4;
+        const forceBottom = posY > rect.bottom - height * 0.4;
+        const preferTop = posY <= rect.top + height * 0.5;
+        const forceLeft = posX <= rect.left + width * 0.4;
+        const forceRight = posX > rect.right - width * 0.4;
+        const preferLeft = posX <= rect.left + width * 0.5;
+        const classes = element.classList;
+        const lastClasses = {
+            vertical: classes.contains('top') ? 'top' : (classes.contains('bottom') ? 'bottom' : undefined),
+            horizontal: classes.contains('left') ? 'left' : (classes.contains('right') ? 'right' : undefined)
+        };
+        const top = forceTop || (preferTop && !lastClasses.vertical) || (!forceBottom && lastClasses.vertical === 'top');
+        const bottom = forceBottom || (!preferTop && !lastClasses.vertical) || (!forceTop && lastClasses.vertical === 'bottom');
+        const left = forceLeft || (preferLeft && !lastClasses.horizontal) || (!forceRight && lastClasses.horizontal === 'left');
+        const right = forceRight || (!preferLeft && !lastClasses.horizontal) || (!forceLeft && lastClasses.horizontal === 'right');
+        element.classList.toggle('top', showFeedback && top);
+        element.classList.toggle('bottom', showFeedback && bottom);
+        element.classList.toggle('left', showFeedback && left);
+        element.classList.toggle('right', showFeedback && right);
+        if (!showFeedback) {
+            return undefined;
+        }
+        return { verticallyBefore: top, horizontallyBefore: left };
+    }
+    showContextMenu(container) {
+        const actions = [this.toggleCompositePinnedAction, this.toggleCompositeBadgeAction];
+        const compositeContextMenuActions = this.compositeContextMenuActionsProvider(this.activity.id);
+        if (compositeContextMenuActions.length) {
+            actions.push(...compositeContextMenuActions);
+        }
+        if (this.compositeActivityAction.activity.extensionId) {
+            actions.push(( new Separator()));
+            actions.push(CompositeActionViewItem.manageExtensionAction);
+        }
+        const isPinned = this.compositeBar.isPinned(this.activity.id);
+        if (isPinned) {
+            this.toggleCompositePinnedAction.label = ( localize('hide', "Hide '{0}'", this.activity.name));
+            this.toggleCompositePinnedAction.checked = false;
+        }
+        else {
+            this.toggleCompositePinnedAction.label = ( localize('keep', "Keep '{0}'", this.activity.name));
+        }
+        const isBadgeEnabled = this.compositeBar.areBadgesEnabled(this.activity.id);
+        if (isBadgeEnabled) {
+            this.toggleCompositeBadgeAction.label = ( localize('hideBadge', "Hide Badge"));
+        }
+        else {
+            this.toggleCompositeBadgeAction.label = ( localize('showBadge', "Show Badge"));
+        }
+        const otherActions = this.contextMenuActionsProvider();
+        if (otherActions.length) {
+            actions.push(( new Separator()));
+            actions.push(...otherActions);
+        }
+        const elementPosition = getDomNodePagePosition(container);
+        const anchor = {
+            x: Math.floor(elementPosition.left + (elementPosition.width / 2)),
+            y: elementPosition.top + elementPosition.height
+        };
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => actions,
+            getActionsContext: () => this.activity.id
+        });
+    }
+    updateChecked() {
+        if (this.action.checked) {
+            this.container.classList.add('checked');
+            this.container.setAttribute('aria-label', this.container.title);
+            this.container.setAttribute('aria-expanded', 'true');
+            this.container.setAttribute('aria-selected', 'true');
+        }
+        else {
+            this.container.classList.remove('checked');
+            this.container.setAttribute('aria-label', this.container.title);
+            this.container.setAttribute('aria-expanded', 'false');
+            this.container.setAttribute('aria-selected', 'false');
+        }
+        this.updateStyles();
+    }
+    updateEnabled() {
+        if (!this.element) {
+            return;
+        }
+        if (this.action.enabled) {
+            this.element.classList.remove('disabled');
+        }
+        else {
+            this.element.classList.add('disabled');
+        }
+    }
+    dispose() {
+        super.dispose();
+        this.label.remove();
+    }
+};
+CompositeActionViewItem = ( __decorate([
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IKeybindingService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, IThemeService)),
+    ( __param(12, IHoverService)),
+    ( __param(13, IConfigurationService))
+], CompositeActionViewItem));
+class ToggleCompositePinnedAction extends Action {
+    constructor(activity, compositeBar) {
+        super('show.toggleCompositePinned', activity ? activity.name : ( localize('toggle', "Toggle View Pinned")));
+        this.activity = activity;
+        this.compositeBar = compositeBar;
+        this.checked = !!this.activity && this.compositeBar.isPinned(this.activity.id);
+    }
+    async run(context) {
+        const id = this.activity ? this.activity.id : context;
+        if (this.compositeBar.isPinned(id)) {
+            this.compositeBar.unpin(id);
+        }
+        else {
+            this.compositeBar.pin(id);
+        }
+    }
+}
+class ToggleCompositeBadgeAction extends Action {
+    constructor(activity, compositeBar) {
+        super('show.toggleCompositeBadge', activity ? activity.name : ( localize('toggleBadge', "Toggle View Badge")));
+        this.activity = activity;
+        this.compositeBar = compositeBar;
+        this.checked = false;
+    }
+    async run(context) {
+        const id = this.activity ? this.activity.id : context;
+        this.compositeBar.toggleBadgeEnablement(id);
+    }
+}
+export { ActivityAction, ActivityActionViewItem, CompositeActionViewItem, CompositeOverflowActivityAction, CompositeOverflowActivityActionViewItem, ToggleCompositeBadgeAction, ToggleCompositePinnedAction };