Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
/**
* Copyright 2023-present DreamNum Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { Dispatch, KeyboardEvent, MouseEvent, RefObject, SetStateAction } from 'react';
import { isRealNum, LocaleService } from '@univerjs/core';
import { borderBottomClassName, borderClassName, clsx, cva, scrollbarClassName } from '@univerjs/design';
import { CheckMarkIcon, MoreLeftIcon, MoreRightIcon } from '@univerjs/icons';
import { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from 'react';
import { createPortal } from 'react-dom';
import { combineLatest, isObservable, map, merge, of, scan, startWith } from 'rxjs';
import type {
IDisplayMenuItem,
IMenuButtonItem,
IMenuItem,
IMenuSelectorItem,
IValueOption,
MenuItemDefaultValueType,
} from '../../../services/menu/menu';
import type { IMenuSchema } from '../../../services/menu/menu-manager.service';
import { ILayoutService } from '../../../services/layout/layout.service';
import { MenuItemType } from '../../../services/menu/menu';
import { IMenuManagerService } from '../../../services/menu/menu-manager.service';
import { useDependency, useObservable } from '../../../utils/di';
import { CustomLabel } from '../../custom-label/CustomLabel';
import { preventBrowserZoomInContainers } from '../../hooks/prevent-browser-zoom';
import { resolveMenuItemActiveState, UIQuickTileMenuGroup, UITinyMenuGroup } from '../../menu/desktop/TinyMenuGroup';
type ContextMenuSizeVariant = 'default' | 'paragraph-t';
type ContextMenuAutoFocusTarget = 'first-item' | 'container';
interface IContextMenuPanelProps {
menuType: string;
menuManagerService?: IMenuManagerService;
layoutService?: ILayoutService;
menuSessionVersion?: number;
className?: string;
activeItemIds?: string[];
hiddenItemIds?: string[];
flowQuickGroups?: boolean;
sizeVariant?: ContextMenuSizeVariant;
autoFocus?: boolean;
autoFocusTarget?: ContextMenuAutoFocusTarget;
suppressHoverUntilPointerMove?: boolean;
onCancel?: () => void;
onMenuPointerEnter?: () => void;
onMenuPointerLeave?: () => void;
onOptionSelect?: (option: IValueOption) => void;
}
interface IContextMenuMenuProps {
menuSchemas: IMenuSchema[];
menuManagerService: IMenuManagerService;
menuSessionVersion: number;
submenuPortalContainer: HTMLElement | null;
rootMenuElement: HTMLElement | null;
maxMenuHeight: number;
activeItemIds?: string[];
hiddenItemIds?: string[];
flowQuickGroups?: boolean;
hoverSuppressed?: boolean;
sizeVariant: ContextMenuSizeVariant;
onMenuPointerEnter?: () => void;
onMenuPointerLeave?: () => void;
onOptionSelect?: (option: IValueOption) => void;
}
interface IContextMenuMenuItemProps {
menuKey: string;
menuItem: IDisplayMenuItem<IMenuItem>;
menuManagerService: IMenuManagerService;
menuSessionVersion: number;
submenuPortalContainer: HTMLElement | null;
rootMenuElement: HTMLElement | null;
maxMenuHeight: number;
activeSubmenuKey: string | null;
setActiveSubmenuKey: Dispatch<SetStateAction<string | null>>;
pointerGraceRef: RefObject<IContextMenuPointerGrace | null>;
activeItemIds?: string[];
hiddenItemIds?: string[];
hoverSuppressed?: boolean;
compact?: boolean;
headerAction?: boolean;
sizeVariant: ContextMenuSizeVariant;
onMenuPointerEnter?: () => void;
onMenuPointerLeave?: () => void;
onOptionSelect?: (option: IValueOption) => void;
}
interface IContextMenuPointerGrace {
menuKey: string;
contains: (event: MouseEvent<HTMLDivElement>) => boolean;
deferHover: (action: (() => void) | null) => void;
cancel: () => void;
}
interface IContextMenuSchemaRenderGroup {
startIndex: number;
endIndex: number;
menuSchemas: IMenuSchema[];
}
const menuViewportPadding = 8;
const submenuOverlapOffset = 2;
const submenuVisualGap = 20;
export const CONTEXT_MENU_SUBMENU_CLOSE_DELAY = 500;
export const CONTEXT_MENU_SUBMENU_PORTAL_ATTR = 'data-u-context-menu-submenu';
const CONTEXT_MENU_CONNECTED_QUICK_GROUP_KEYS = new Set(['quickTop', 'quickBottom']);
const CONTEXT_MENU_HEADER_QUICK_GROUP_KEYS = new Set(['quickTop', 'quickBottom']);
const CONTEXT_MENU_NAVIGATION_KEYS = new Set(['ArrowDown', 'ArrowUp', 'ArrowLeft', 'ArrowRight']);
type MenuLabel = IMenuItem['label'] | IValueOption['label'];
type ContextMenuQuickGroupConnection = 'none' | 'previous' | 'next' | 'both';
type ContextMenuItemVariant = 'default' | 'compact' | 'compactHeaderAction';
const contextMenuContentVariants = cva('univer-inline-flex univer-items-center', {
variants: {
sizeVariant: {
default: 'univer-gap-2',
'paragraph-t': 'univer-gap-3',
},
},
defaultVariants: {
sizeVariant: 'default',
},
});
const contextMenuPanelVariants = cva(
`
univer-box-border univer-grid univer-max-w-full univer-overflow-y-auto univer-overscroll-contain univer-rounded-md
univer-bg-gray-0 univer-text-gray-900 univer-shadow-md
dark:!univer-bg-gray-700 dark:!univer-text-gray-0
`,
{
variants: {
sizeVariant: {
default: 'univer-min-w-52 univer-gap-1 univer-px-2 univer-py-1 univer-text-sm',
'paragraph-t': 'univer-min-w-64 univer-gap-2 univer-px-3 univer-py-2 univer-text-base',
},
},
defaultVariants: {
sizeVariant: 'default',
},
}
);
const contextMenuGroupVariants = cva('univer-grid', {
variants: {
sizeVariant: {
default: 'univer-gap-1 univer-py-1',
'paragraph-t': 'univer-gap-2 univer-py-2',
},
},
defaultVariants: {
sizeVariant: 'default',
},
});
const contextMenuQuickGroupVariants = cva('univer-grid', {
variants: {
sizeVariant: {
default: 'univer-gap-1 univer-py-1',
'paragraph-t': 'univer-gap-2 univer-py-2',
},
connection: {
none: '',
previous: '',
next: '',
both: '',
},
},
compoundVariants: [
{
sizeVariant: 'paragraph-t',
connection: 'previous',
class: 'univer-pb-2 univer-pt-1',
},
{
sizeVariant: 'paragraph-t',
connection: 'next',
class: 'univer-pb-1 univer-pt-2',
},
{
sizeVariant: 'paragraph-t',
connection: 'both',
class: 'univer-pb-1 univer-pt-1',
},
],
defaultVariants: {
sizeVariant: 'default',
connection: 'none',
},
});
const contextMenuQuickGroupClusterVariants = cva('univer-grid', {
variants: {
sizeVariant: {
default: 'univer-gap-1 univer-py-1',
'paragraph-t': 'univer-gap-0 univer-py-2',
},
},
defaultVariants: {
sizeVariant: 'default',
},
});
const contextMenuHeaderVariants = cva(`
univer-font-semibold univer-text-gray-600
dark:!univer-text-gray-300
`, {
variants: {
sizeVariant: {
default: 'univer-px-2 univer-text-xs',
'paragraph-t': 'univer-px-3 univer-text-sm',
},
},
defaultVariants: {
sizeVariant: 'default',
},
});
const contextMenuHeaderRowVariants = cva('univer-flex univer-items-center univer-justify-between', {
variants: {
sizeVariant: {
default: 'univer-gap-1.5',
'paragraph-t': 'univer-gap-2',
},
},
defaultVariants: {
sizeVariant: 'default',
},
});
const contextMenuSubmenuPanelVariants = cva(
`
univer-overflow-y-auto univer-overscroll-contain univer-rounded-md univer-border univer-border-solid
univer-border-gray-200 univer-bg-gray-0 univer-shadow-md
dark:!univer-border-gray-600 dark:!univer-bg-gray-700
`,
{
variants: {
sizeVariant: {
default: 'univer-p-1.5',
'paragraph-t': 'univer-p-2',
},
},
defaultVariants: {
sizeVariant: 'default',
},
}
);
const contextMenuItemVariants = cva(
`
univer-relative univer-flex univer-border-none univer-bg-transparent univer-text-left univer-text-gray-900
rtl:!univer-text-right
dark:!univer-text-gray-0
`,
{
variants: {
sizeVariant: {
default: '',
'paragraph-t': '',
},
variant: {
default: '',
compact: '',
compactHeaderAction: '',
},
disabled: {
true: 'univer-cursor-not-allowed univer-opacity-60',
false: `
univer-cursor-pointer
focus:univer-outline-none
focus-visible:univer-ring-2 focus-visible:univer-ring-inset focus-visible:univer-ring-primary-500
`,
},
submenuOpen: {
true: `
univer-bg-gray-50
dark:!univer-bg-gray-600
`,
false: '',
},
hoverSuppressed: {
true: '',
false: '',
},
active: {
true: `
univer-bg-gray-200
dark:!univer-bg-gray-600
`,
false: '',
},
},
compoundVariants: [
{
sizeVariant: 'default',
variant: 'default',
class: `
univer-min-h-8 univer-w-full univer-items-center univer-justify-between univer-gap-3 univer-rounded-md
univer-px-2 univer-text-sm
`,
},
{
sizeVariant: 'default',
variant: 'compact',
class: `
univer-size-8 univer-items-center univer-justify-center univer-rounded-md univer-p-0 univer-text-sm
`,
},
{
sizeVariant: 'default',
variant: 'compactHeaderAction',
class: `
univer-size-7 univer-items-center univer-justify-center univer-rounded-sm univer-p-0 univer-text-sm
`,
},
{
sizeVariant: 'paragraph-t',
variant: 'default',
class: `
univer-min-h-10 univer-w-full univer-items-center univer-justify-between univer-gap-4
univer-rounded-lg univer-px-3 univer-text-base
`,
},
{
sizeVariant: 'paragraph-t',
variant: 'compact',
class: `
univer-size-10 univer-items-center univer-justify-center univer-rounded-lg univer-p-0 univer-text-base
`,
},
{
sizeVariant: 'paragraph-t',
variant: 'compactHeaderAction',
class: `
univer-size-8 univer-items-center univer-justify-center univer-rounded-md univer-p-0 univer-text-base
`,
},
{
disabled: false,
hoverSuppressed: false,
class: `
hover:univer-bg-gray-50
dark:hover:!univer-bg-gray-600
`,
},
],
defaultVariants: {
sizeVariant: 'default',
variant: 'default',
disabled: false,
hoverSuppressed: false,
active: false,
},
}
);
function isNonSelectableLabel(label?: MenuLabel) {
return typeof label === 'object' && label?.selectable === false;
}
function isNonHoverableLabel(label?: MenuLabel) {
return typeof label === 'object' && label?.hoverable === false;
}
export function hasRenderableContextMenuSchema(menuSchema: IMenuSchema): boolean {
if (menuSchema.item) {
return true;
}
if (!menuSchema.children?.length) {
return false;
}
return menuSchema.children.some((childSchema) => Boolean(childSchema.item));
}
export function shouldShowContextMenuGroupSeparator(visibleSchemas: IMenuSchema[], index: number): boolean {
if (index === visibleSchemas.length - 1) {
return false;
}
const currentSchema = visibleSchemas[index];
const nextSchema = visibleSchemas[index + 1];
if (
currentSchema?.quickLayout
&& nextSchema?.quickLayout
&& CONTEXT_MENU_CONNECTED_QUICK_GROUP_KEYS.has(currentSchema.key)
&& CONTEXT_MENU_CONNECTED_QUICK_GROUP_KEYS.has(nextSchema.key)
) {
return false;
}
return true;
}
export function getContextMenuQuickGroupColumns(menuSchema: IMenuSchema): number | undefined {
if (isRealNum(menuSchema.quickColumns)) {
return menuSchema.quickColumns;
}
if (menuSchema.quickLayout === 'icon' && CONTEXT_MENU_HEADER_QUICK_GROUP_KEYS.has(menuSchema.key)) {
return 6;
}
return undefined;
}
function isContextMenuPointerLeaveTarget(
nextTarget: Node | null,
owningMenuItemElement: HTMLElement | null,
rootMenuElement: HTMLElement | null
) {
if (!nextTarget) {
return true;
}
if (owningMenuItemElement?.contains(nextTarget) || rootMenuElement?.contains(nextTarget)) {
return false;
}
return true;
}
function getContextMenuContentClassName(sizeVariant: ContextMenuSizeVariant) {
return contextMenuContentVariants({ sizeVariant });
}
function getContextMenuPanelClassName(sizeVariant: ContextMenuSizeVariant) {
return contextMenuPanelVariants({ sizeVariant });
}
function getContextMenuGroupClassName(sizeVariant: ContextMenuSizeVariant) {
return contextMenuGroupVariants({ sizeVariant });
}
function isHeaderQuickGroup(menuSchema: IMenuSchema) {
return menuSchema.quickLayout === 'icon'
&& CONTEXT_MENU_HEADER_QUICK_GROUP_KEYS.has(menuSchema.key);
}
function shouldClusterHeaderQuickGroups(
currentSchema: IMenuSchema,
nextSchema: IMenuSchema | undefined
) {
return isHeaderQuickGroup(currentSchema)
&& !!nextSchema
&& isHeaderQuickGroup(nextSchema);
}
function getContextMenuQuickGroupClassName(
menuSchema: IMenuSchema,
visibleSchemas: IMenuSchema[],
index: number,
sizeVariant: ContextMenuSizeVariant
) {
if (sizeVariant !== 'paragraph-t' || !CONTEXT_MENU_HEADER_QUICK_GROUP_KEYS.has(menuSchema.key)) {
return getContextMenuGroupClassName(sizeVariant);
}
const previousSchema = index > 0 ? visibleSchemas[index - 1] : null;
const nextSchema = index < visibleSchemas.length - 1 ? visibleSchemas[index + 1] : null;
const connectedToPrevious = !!previousSchema?.quickLayout && CONTEXT_MENU_HEADER_QUICK_GROUP_KEYS.has(previousSchema.key);
const connectedToNext = !!nextSchema?.quickLayout && CONTEXT_MENU_HEADER_QUICK_GROUP_KEYS.has(nextSchema.key);
const connection: ContextMenuQuickGroupConnection = connectedToPrevious && connectedToNext
? 'both'
: connectedToPrevious
? 'previous'
: connectedToNext
? 'next'
: 'none';
return contextMenuQuickGroupVariants({ sizeVariant, connection });
}
function getContextMenuQuickGroupClusterClassName(sizeVariant: ContextMenuSizeVariant) {
return contextMenuQuickGroupClusterVariants({ sizeVariant });
}
function getMenuButtonCenter(button: HTMLButtonElement) {
const rect = button.getBoundingClientRect();
return {
x: rect.left + rect.width / 2,
y: rect.top + rect.height / 2,
};
}
function getMenuButtonRows(buttons: HTMLButtonElement[]): HTMLButtonElement[][] {
const sortedButtons = [...buttons].sort((left, right) => {
const leftRect = left.getBoundingClientRect();
const rightRect = right.getBoundingClientRect();
return leftRect.top - rightRect.top || leftRect.left - rightRect.left;
});
const rows: HTMLButtonElement[][] = [];
for (const button of sortedButtons) {
const rect = button.getBoundingClientRect();
const centerY = rect.top + rect.height / 2;
const row = rows.find((candidateRow) => {
const rowRect = candidateRow[0].getBoundingClientRect();
const rowCenterY = rowRect.top + rowRect.height / 2;
const tolerance = Math.max(4, Math.max(rowRect.height, rect.height) / 2);
return Math.abs(rowCenterY - centerY) <= tolerance;
});
if (row) {
row.push(button);
} else {
rows.push([button]);
}
}
rows.forEach((row) => row.sort((left, right) => left.getBoundingClientRect().left - right.getBoundingClientRect().left));
return rows;
}
function getFirstMenuButtonByVisualOrder(buttons: HTMLButtonElement[]): HTMLButtonElement | undefined {
return [...buttons].sort((left, right) => {
const leftRect = left.getBoundingClientRect();
const rightRect = right.getBoundingClientRect();
return leftRect.top - rightRect.top || leftRect.left - rightRect.left;
})[0];
}
export function getNextMenuButtonByDirection(
buttons: HTMLButtonElement[],
activeIndex: number,
key: string
): HTMLButtonElement {
const direction = key === 'ArrowDown' || key === 'ArrowRight' ? 1 : -1;
const fallbackIndex = activeIndex < 0
? (direction > 0 ? 0 : buttons.length - 1)
: (activeIndex + direction + buttons.length) % buttons.length;
const fallbackButton = buttons[fallbackIndex];
const activeButton = activeIndex >= 0 ? buttons[activeIndex] : null;
if (!activeButton) {
return fallbackButton;
}
const rows = getMenuButtonRows(buttons);
const activeRowIndex = rows.findIndex((row) => row.includes(activeButton));
const activeRow = rows[activeRowIndex];
if (activeRow && (key === 'ArrowRight' || key === 'ArrowLeft')) {
const rowButtonIndex = activeRow.indexOf(activeButton);
const nextRowButton = activeRow[rowButtonIndex + (key === 'ArrowRight' ? 1 : -1)];
return nextRowButton ?? fallbackButton;
}
if (activeRow && (key === 'ArrowDown' || key === 'ArrowUp')) {
const nextRow = rows[activeRowIndex + (key === 'ArrowDown' ? 1 : -1)];
if (nextRow) {
const activeCenter = getMenuButtonCenter(activeButton);
return [...nextRow].sort((left, right) => (
Math.abs(getMenuButtonCenter(left).x - activeCenter.x) - Math.abs(getMenuButtonCenter(right).x - activeCenter.x)
))[0] ?? fallbackButton;
}
}
const activeCenter = getMenuButtonCenter(activeButton);
const scoredCandidates = buttons
.filter((button) => button !== activeButton)
.map((button) => {
const center = getMenuButtonCenter(button);
const deltaX = center.x - activeCenter.x;
const deltaY = center.y - activeCenter.y;
const isCandidate = key === 'ArrowRight'
? deltaX > 0
: key === 'ArrowLeft'
? deltaX < 0
: key === 'ArrowDown'
? deltaY > 0
: deltaY < 0;
if (!isCandidate) {
return null;
}
const primaryDistance = key === 'ArrowRight' || key === 'ArrowLeft'
? Math.abs(deltaX)
: Math.abs(deltaY);
const secondaryDistance = key === 'ArrowRight' || key === 'ArrowLeft'
? Math.abs(deltaY)
: Math.abs(deltaX);
return {
button,
score: primaryDistance * 1000 + secondaryDistance,
};
})
.filter((candidate): candidate is { button: HTMLButtonElement; score: number } => candidate != null)
.sort((left, right) => left.score - right.score);
return scoredCandidates[0]?.button ?? fallbackButton;
}
export function getContextMenuSchemaRenderGroups(
visibleSchemas: IMenuSchema[],
flowQuickGroups = false
): IContextMenuSchemaRenderGroup[] {
const renderGroups: IContextMenuSchemaRenderGroup[] = [];
for (let index = 0; index < visibleSchemas.length; index++) {
const menuSchema = visibleSchemas[index];
const nextSchema = visibleSchemas[index + 1];
if (flowQuickGroups && shouldClusterHeaderQuickGroups(menuSchema, nextSchema)) {
renderGroups.push({
startIndex: index,
endIndex: index + 1,
menuSchemas: [menuSchema, nextSchema!],
});
index += 1;
continue;
}
renderGroups.push({
startIndex: index,
endIndex: index,
menuSchemas: [menuSchema],
});
}
return renderGroups;
}
function mergeContextMenuQuickGroupSchemas(menuSchemas: IMenuSchema[]): IMenuSchema {
const firstSchema = menuSchemas[0];
return {
...firstSchema,
key: menuSchemas.map((schema) => schema.key).join('-'),
quickColumns: getContextMenuQuickGroupColumns(firstSchema),
children: menuSchemas.flatMap((schema) => schema.children ?? []),
};
}
function getContextMenuHeaderClassName(sizeVariant: ContextMenuSizeVariant) {
return contextMenuHeaderVariants({ sizeVariant });
}
function getContextMenuHeaderRowClassName(sizeVariant: ContextMenuSizeVariant) {
return contextMenuHeaderRowVariants({ sizeVariant });
}
function getContextMenuSubmenuPanelClassName(sizeVariant: ContextMenuSizeVariant) {
return contextMenuSubmenuPanelVariants({ sizeVariant });
}
export function ContextMenuPanel(props: IContextMenuPanelProps) {
const {
menuType,
menuManagerService: providedMenuManagerService,
layoutService: providedLayoutService,
menuSessionVersion = 0,
className,
activeItemIds,
hiddenItemIds,
flowQuickGroups,
sizeVariant = 'default',
autoFocus,
autoFocusTarget = 'first-item',
suppressHoverUntilPointerMove = false,
onCancel,
onMenuPointerEnter,
onMenuPointerLeave,
onOptionSelect,
} = props;
const rootMenuManagerService = useDependency(IMenuManagerService);
const rootLayoutService = useDependency(ILayoutService);
const menuManagerService = providedMenuManagerService ?? rootMenuManagerService;
const layoutService = providedLayoutService ?? rootLayoutService;
const [menuElement, setMenuElement] = useState<HTMLDivElement | null>(null);
const [maxMenuHeight, setMaxMenuHeight] = useState(() => {
if (typeof window === 'undefined') {
return 240;
}
return Math.max(120, window.innerHeight - menuViewportPadding * 2);
});
const [hoverSuppressed, setHoverSuppressed] = useState(suppressHoverUntilPointerMove);
const menuSchemaVersion$ = useMemo(
() => menuManagerService.menuChanged$.pipe(startWith(undefined), scan((version) => version + 1, 0)),
[menuManagerService]
);
const menuSchemaVersion = useObservable(menuSchemaVersion$, 0);
const menuItems = useMemo(
() => (menuType ? menuManagerService.getMenuByPositionKey(menuType) : []),
[menuManagerService, menuType, menuSchemaVersion, menuSessionVersion]
);
const submenuPortalContainer = layoutService.rootContainerElement?.ownerDocument?.body
?? (typeof document !== 'undefined' ? document.body : null);
useEffect(() => {
if (!menuElement) {
return;
}
return preventBrowserZoomInContainers([menuElement]);
}, [menuElement]);
const getFocusableMenuButtons = useCallback((scope?: Element | null) => {
const menuScope = scope ?? menuElement;
if (!menuScope) {
return [];
}
return Array.from(menuScope.querySelectorAll<HTMLButtonElement>('button:not(:disabled)'));
}, [menuElement]);
useEffect(() => {
if (!autoFocus || !menuElement) {
return;
}
const view = menuElement.ownerDocument.defaultView ?? window;
const frameId = view.requestAnimationFrame(() => {
if (autoFocusTarget === 'container') {
menuElement.focus();
return;
}
const firstButton = getFirstMenuButtonByVisualOrder(getFocusableMenuButtons());
(firstButton ?? menuElement).focus();
});
return () => view.cancelAnimationFrame(frameId);
}, [autoFocus, autoFocusTarget, getFocusableMenuButtons, menuElement, menuItems]);
useEffect(() => {
setHoverSuppressed(suppressHoverUntilPointerMove);
}, [menuSessionVersion, menuType, suppressHoverUntilPointerMove]);
const handleKeyDown = useCallback((event: KeyboardEvent<HTMLDivElement>) => {
if (event.key === 'Escape') {
event.preventDefault();
event.stopPropagation();
onCancel?.();
return;
}
if (!CONTEXT_MENU_NAVIGATION_KEYS.has(event.key) && event.key !== 'Enter') {
return;
}
const activeElement = menuElement?.ownerDocument.activeElement;
const activeSubmenu = activeElement?.closest(`[${CONTEXT_MENU_SUBMENU_PORTAL_ATTR}]`) ?? null;
const focusableButtons = getFocusableMenuButtons(activeSubmenu);
if (!focusableButtons.length) {
return;
}
event.preventDefault();
event.stopPropagation();
const activeIndex = focusableButtons.findIndex((button) => button.contains(activeElement ?? null));
if (event.key === 'Enter') {
const button = activeIndex >= 0 ? focusableButtons[activeIndex] : getFirstMenuButtonByVisualOrder(focusableButtons);
if (!button) {
return;
}
button.click();
return;
}
getNextMenuButtonByDirection(focusableButtons, activeIndex, event.key).focus();
}, [getFocusableMenuButtons, menuElement, onCancel]);
useEffect(() => {
const defaultView = layoutService.rootContainerElement?.ownerDocument?.defaultView
?? (typeof window !== 'undefined' ? window : null);
if (!defaultView) {
return;
}
let frameId = 0;
const updateMaxHeight = () => {
if (frameId) {
defaultView.cancelAnimationFrame(frameId);
}
frameId = defaultView.requestAnimationFrame(() => {
setMaxMenuHeight(Math.max(120, defaultView.innerHeight - menuViewportPadding * 2));
});
};
updateMaxHeight();
defaultView.addEventListener('resize', updateMaxHeight);
return () => {
if (frameId) {
defaultView.cancelAnimationFrame(frameId);
}
defaultView.removeEventListener('resize', updateMaxHeight);
};
}, [layoutService.rootContainerElement]);
if (!menuType) {
return null;
}
return (
<div
ref={setMenuElement}
tabIndex={-1}
className={clsx(
getContextMenuPanelClassName(sizeVariant),
borderClassName,
scrollbarClassName,
hoverSuppressed && '[&_button:hover:not(:focus)]:!univer-bg-transparent',
className
)}
style={{
maxHeight: maxMenuHeight,
}}
onKeyDown={handleKeyDown}
onPointerMove={() => {
if (hoverSuppressed) {
setHoverSuppressed(false);
}
}}
onWheel={(event) => event.stopPropagation()}
>
<ContextMenuMenu
menuSchemas={menuItems}
menuManagerService={menuManagerService}
menuSessionVersion={menuSessionVersion}
submenuPortalContainer={submenuPortalContainer}
rootMenuElement={menuElement}
activeItemIds={activeItemIds}
hiddenItemIds={hiddenItemIds}
flowQuickGroups={flowQuickGroups}
hoverSuppressed={hoverSuppressed}
sizeVariant={sizeVariant}
onMenuPointerEnter={onMenuPointerEnter}
onMenuPointerLeave={onMenuPointerLeave}
onOptionSelect={onOptionSelect}
maxMenuHeight={maxMenuHeight}
/>
</div>
);
}
function ContextMenuMenu(props: IContextMenuMenuProps) {
const { menuSchemas, menuManagerService, menuSessionVersion, submenuPortalContainer, rootMenuElement, activeItemIds, hiddenItemIds, flowQuickGroups, hoverSuppressed, sizeVariant, onMenuPointerEnter, onMenuPointerLeave, onOptionSelect, maxMenuHeight } = props;
const localeService = useDependency(LocaleService);
const hiddenGroupStates = useContextGroupHiddenStates(menuSchemas);
const [activeSubmenuKey, setActiveSubmenuKey] = useState<string | null>(null);
const pointerGraceRef = useRef<IContextMenuPointerGrace | null>(null);
const visibleSchemas = useMemo(() => {
return menuSchemas.filter((item) => {
if (!hasRenderableContextMenuSchema(item)) {
return false;
}
if (!item.children) {
return true;
}
return !hiddenGroupStates[item.key];
});
}, [hiddenGroupStates, menuSchemas]);
const renderGroups = useMemo(
() => getContextMenuSchemaRenderGroups(visibleSchemas, flowQuickGroups),
[flowQuickGroups, visibleSchemas]
);
const renderQuickLayoutGroup = (
menuSchema: IMenuSchema,
index: number,
renderAsClusterChild = false,
hasSeparator = false
) => {
const titleNode = renderMenuSchemaHeader(menuSchema);
return (
<div
key={menuSchema.key}
className={clsx(
renderAsClusterChild
? 'univer-grid'
: getContextMenuQuickGroupClassName(menuSchema, visibleSchemas, index, sizeVariant),
hasSeparator && borderBottomClassName
)}
>
{titleNode}
{menuSchema.quickLayout === 'tile'
? (
<UIQuickTileMenuGroup
item={menuSchema}
activeItemIds={activeItemIds}
hiddenItemIds={hiddenItemIds}
hoverSuppressed={hoverSuppressed}
onOptionSelect={onOptionSelect}
/>
)
: (
<UITinyMenuGroup
item={menuSchema}
columns={getContextMenuQuickGroupColumns(menuSchema)}
activeItemIds={activeItemIds}
hiddenItemIds={hiddenItemIds}
hoverSuppressed={hoverSuppressed}
sizeVariant={sizeVariant}
layoutVariant={menuSchema.quickLayoutVariant}
onOptionSelect={onOptionSelect}
/>
)}
</div>
);
};
return (
<>
{renderGroups.map(({ menuSchemas: groupedSchemas, startIndex, endIndex }) => {
const menuSchema = groupedSchemas[0];
const hasSeparator = shouldShowContextMenuGroupSeparator(visibleSchemas, endIndex);
const titleNode = renderMenuSchemaHeader(menuSchema);
if (groupedSchemas.length > 1) {
const mergedMenuSchema = mergeContextMenuQuickGroupSchemas(groupedSchemas);
return (
<div
key={groupedSchemas.map((schema) => schema.key).join('-')}
className={clsx(
getContextMenuQuickGroupClusterClassName(sizeVariant),
hasSeparator && borderBottomClassName
)}
>
{renderQuickLayoutGroup(mergedMenuSchema, startIndex, true)}
</div>
);
}
if (menuSchema.item) {
return (
<ContextMenuMenuItem
key={menuSchema.key}
menuKey={menuSchema.key}
menuItem={menuSchema.item as IDisplayMenuItem<IMenuItem>}
menuManagerService={menuManagerService}
menuSessionVersion={menuSessionVersion}
submenuPortalContainer={submenuPortalContainer}
rootMenuElement={rootMenuElement}
activeSubmenuKey={activeSubmenuKey}
setActiveSubmenuKey={setActiveSubmenuKey}
pointerGraceRef={pointerGraceRef}
onOptionSelect={onOptionSelect}
maxMenuHeight={maxMenuHeight}
hiddenItemIds={hiddenItemIds}
hoverSuppressed={hoverSuppressed}
sizeVariant={sizeVariant}
onMenuPointerEnter={onMenuPointerEnter}
onMenuPointerLeave={onMenuPointerLeave}
/>
);
}
if (!menuSchema.children?.length) {
return null;
}
if (menuSchema.quickLayout) {
return renderQuickLayoutGroup(menuSchema, startIndex, false, hasSeparator);
}
if (menuSchema.tiny) {
return (
<div
key={menuSchema.key}
className={clsx(
sizeVariant === 'paragraph-t'
? 'univer-flex univer-items-center univer-gap-2 univer-py-2'
: 'univer-flex univer-items-center univer-gap-1 univer-py-1',
hasSeparator && borderBottomClassName
)}
>
{menuSchema.children.map((childSchema) => (
childSchema.item && (
<ContextMenuMenuItem
key={childSchema.key}
menuKey={childSchema.key}
menuItem={childSchema.item as IDisplayMenuItem<IMenuItem>}
menuManagerService={menuManagerService}
menuSessionVersion={menuSessionVersion}
submenuPortalContainer={submenuPortalContainer}
rootMenuElement={rootMenuElement}
activeSubmenuKey={activeSubmenuKey}
setActiveSubmenuKey={setActiveSubmenuKey}
pointerGraceRef={pointerGraceRef}
activeItemIds={activeItemIds}
hiddenItemIds={hiddenItemIds}
hoverSuppressed={hoverSuppressed}
onMenuPointerEnter={onMenuPointerEnter}
onMenuPointerLeave={onMenuPointerLeave}
onOptionSelect={onOptionSelect}
maxMenuHeight={maxMenuHeight}
compact
sizeVariant={sizeVariant}
/>
)
))}
</div>
);
}
return (
<div
key={menuSchema.key}
className={clsx(
getContextMenuGroupClassName(sizeVariant),
hasSeparator && borderBottomClassName
)}
>
{titleNode}
{menuSchema.children.map((childSchema) => (
childSchema.item && (
<ContextMenuMenuItem
key={childSchema.key}
menuKey={childSchema.key}
menuItem={childSchema.item as IDisplayMenuItem<IMenuItem>}
menuManagerService={menuManagerService}
menuSessionVersion={menuSessionVersion}
submenuPortalContainer={submenuPortalContainer}
rootMenuElement={rootMenuElement}
activeSubmenuKey={activeSubmenuKey}
setActiveSubmenuKey={setActiveSubmenuKey}
pointerGraceRef={pointerGraceRef}
activeItemIds={activeItemIds}
hiddenItemIds={hiddenItemIds}
hoverSuppressed={hoverSuppressed}
onMenuPointerEnter={onMenuPointerEnter}
onMenuPointerLeave={onMenuPointerLeave}
onOptionSelect={onOptionSelect}
maxMenuHeight={maxMenuHeight}
sizeVariant={sizeVariant}
/>
)
))}
</div>
);
})}
</>
);
function renderMenuSchemaHeader(menuSchema: IMenuSchema) {
if (!menuSchema.title) {
return null;
}
const titleContent = (
<strong
className={getContextMenuHeaderClassName(sizeVariant)}
>
{localeService.t(menuSchema.title)}
</strong>
);
if (!menuSchema.headerActionItem) {
return titleContent;
}
return (
<div className={getContextMenuHeaderRowClassName(sizeVariant)}>
{titleContent}
<ContextMenuMenuItem
menuKey={`${menuSchema.key}-header-action`}
menuItem={menuSchema.headerActionItem as IDisplayMenuItem<IMenuItem>}
menuManagerService={menuManagerService}
menuSessionVersion={menuSessionVersion}
submenuPortalContainer={submenuPortalContainer}
rootMenuElement={rootMenuElement}
activeSubmenuKey={activeSubmenuKey}
setActiveSubmenuKey={setActiveSubmenuKey}
pointerGraceRef={pointerGraceRef}
activeItemIds={activeItemIds}
hiddenItemIds={hiddenItemIds}
hoverSuppressed={hoverSuppressed}
compact
headerAction
sizeVariant={sizeVariant}
onMenuPointerEnter={onMenuPointerEnter}
onMenuPointerLeave={onMenuPointerLeave}
onOptionSelect={onOptionSelect}
maxMenuHeight={maxMenuHeight}
/>
</div>
);
}
}
function ContextMenuMenuItem(props: IContextMenuMenuItemProps) {
const {
menuKey,
menuItem,
menuManagerService,
menuSessionVersion,
submenuPortalContainer,
rootMenuElement,
maxMenuHeight,
activeSubmenuKey,
setActiveSubmenuKey,
pointerGraceRef,
activeItemIds,
hiddenItemIds = [],
hoverSuppressed = false,
compact = false,
headerAction = false,
sizeVariant,
onMenuPointerEnter,
onMenuPointerLeave,
onOptionSelect,
} = props;
const localeService = useDependency(LocaleService);
const direction = useObservable(localeService.direction$);
const disabled = useObservable<boolean>(menuItem.disabled$, false);
const activated = useObservable<boolean>(menuItem.activated$, false);
const hidden = useObservable<boolean>(menuItem.hidden$, false);
const value = useObservable<MenuItemDefaultValueType>(menuItem.value$);
const selectorItem = menuItem as IDisplayMenuItem<IMenuSelectorItem>;
const selectionsFromObservable = useObservable(
isObservable(selectorItem.selections) ? selectorItem.selections : undefined
);
const [inputValue, setInputValue] = useState(value);
const [submenuPosition, setSubmenuPosition] = useState<{
left: number;
top: number;
}>({
left: 0,
top: 0,
});
const [submenuPositionReady, setSubmenuPositionReady] = useState(false);
const [submenuPlacement, setSubmenuPlacement] = useState<'left' | 'right'>('right');
const [keyboardSubmenuFocusRequested, setKeyboardSubmenuFocusRequested] = useState(false);
const menuItemElementRef = useRef<HTMLDivElement | null>(null);
const menuButtonRef = useRef<HTMLButtonElement | null>(null);
const mouseDownOnInputRef = useRef(false);
const submenuElementRef = useRef<HTMLDivElement | null>(null);
const submenuCloseTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
const pendingHoverActionRef = useRef<(() => void) | null>(null);
const submenuId = useId();
const selections = useMemo(() => {
if (menuItem.type !== MenuItemType.SELECTOR && menuItem.type !== MenuItemType.BUTTON_SELECTOR) {
return [];
}
if (selectionsFromObservable) {
return selectionsFromObservable;
}
return Array.isArray(selectorItem.selections) ? selectorItem.selections : [];
}, [menuItem.type, selectionsFromObservable, selectorItem.selections]);
const subMenuItems = useMemo(() => {
if (menuItem.type !== MenuItemType.SUBITEMS || !menuItem.id) {
return [];
}
return menuManagerService.getMenuByPositionKey(menuItem.id);
}, [menuItem.id, menuItem.type, menuManagerService, menuSessionVersion]);
const hasSelectionSubmenu = selections.length > 0;
const hasSubItemSubmenu = subMenuItems.length > 0;
const hasSubmenu = hasSelectionSubmenu || hasSubItemSubmenu;
const submenuVisible = hasSubmenu && activeSubmenuKey === menuKey;
const selectionsCommandId = selectorItem.selectionsCommandId;
const clearSubmenuCloseTimer = useCallback(() => {
if (submenuCloseTimerRef.current != null) {
clearTimeout(submenuCloseTimerRef.current);
submenuCloseTimerRef.current = null;
}
pendingHoverActionRef.current = null;
if (pointerGraceRef.current?.menuKey === menuKey) {
pointerGraceRef.current = null;
}
}, [menuKey, pointerGraceRef]);
const closeSubmenu = useCallback(() => {
clearSubmenuCloseTimer();
setActiveSubmenuKey((currentKey) => (currentKey === menuKey ? null : currentKey));
}, [clearSubmenuCloseTimer, menuKey, setActiveSubmenuKey]);
const scheduleSubmenuClose = useCallback(() => {
clearSubmenuCloseTimer();
submenuCloseTimerRef.current = setTimeout(() => {
const pendingHoverAction = pendingHoverActionRef.current;
clearSubmenuCloseTimer();
if (pendingHoverAction) {
pendingHoverAction();
} else if (!submenuElementRef.current?.contains(document.activeElement)) {
closeSubmenu();
}
}, CONTEXT_MENU_SUBMENU_CLOSE_DELAY);
}, [clearSubmenuCloseTimer, closeSubmenu]);
useEffect(() => {
setInputValue(value);
}, [value]);
useEffect(() => () => clearSubmenuCloseTimer(), [clearSubmenuCloseTimer]);
useEffect(() => {
if (disabled || !submenuVisible) {
closeSubmenu();
}
}, [closeSubmenu, disabled, submenuVisible]);
useEffect(() => {
const submenuElement = submenuElementRef.current;
if (!submenuVisible || !submenuElement) {
return;
}
return preventBrowserZoomInContainers([submenuElement]);
}, [submenuVisible]);
useLayoutEffect(() => {
if (!submenuVisible || !submenuPositionReady || !keyboardSubmenuFocusRequested) {
return;
}
const firstEnabledButton = submenuElementRef.current?.querySelector<HTMLButtonElement>('button:not(:disabled)');
firstEnabledButton?.focus();
}, [keyboardSubmenuFocusRequested, submenuPositionReady, submenuVisible]);
useEffect(() => {
if (!submenuVisible) {
setSubmenuPositionReady(false);
return;
}
const updateSubmenuPosition = () => {
const menuItemElement = menuItemElementRef.current;
const submenuElement = submenuElementRef.current;
if (!menuItemElement || !submenuElement) {
return;
}
const menuItemRect = menuItemElement.getBoundingClientRect();
const submenuRect = submenuElement.getBoundingClientRect();
const rightLeft = menuItemRect.right - submenuOverlapOffset;
const leftLeft = menuItemRect.left - submenuRect.width + submenuOverlapOffset;
const hasLeftSpace = leftLeft >= menuViewportPadding;
const hasRightSpace = rightLeft + submenuRect.width + menuViewportPadding <= window.innerWidth;
const useLeft = direction === 'rtl'
? hasLeftSpace || !hasRightSpace
: !hasRightSpace && hasLeftSpace;
const left = useLeft ? leftLeft : rightLeft;
setSubmenuPlacement(useLeft ? 'left' : 'right');
const maxTop = window.innerHeight - menuViewportPadding - submenuRect.height;
const top = maxTop < menuViewportPadding
? menuViewportPadding
: Math.min(Math.max(menuItemRect.top, menuViewportPadding), maxTop);
setSubmenuPosition({ left, top });
setSubmenuPositionReady(true);
};
const frameId = window.requestAnimationFrame(updateSubmenuPosition);
const resizeObserver = new ResizeObserver(updateSubmenuPosition);
if (submenuElementRef.current) {
resizeObserver.observe(submenuElementRef.current);
}
window.addEventListener('resize', updateSubmenuPosition);
window.addEventListener('scroll', updateSubmenuPosition, true);
return () => {
window.cancelAnimationFrame(frameId);
resizeObserver.disconnect();
window.removeEventListener('resize', updateSubmenuPosition);
window.removeEventListener('scroll', updateSubmenuPosition, true);
};
}, [direction, submenuVisible, hasSelectionSubmenu, hasSubItemSubmenu]);
const hiddenById = (menuItem.id != null && hiddenItemIds.includes(menuItem.id)) || hiddenItemIds.includes(menuKey);
if (hidden || hiddenById) {
return null;
}
const onChange = (v: string | number) => {
const newValue = isRealNum(v) && typeof v === 'string' ? Number.parseInt(v) : v;
setInputValue(newValue);
};
const onSubmenuOptionSelect = (option: IValueOption) => {
onOptionSelect?.(option);
clearSubmenuCloseTimer();
setActiveSubmenuKey((currentKey) => (currentKey === menuKey ? null : currentKey));
};
const onPointerHover = (event: MouseEvent<HTMLDivElement>) => {
if (hoverSuppressed || (hasSubmenu && disabled)) {
return;
}
const applyHover = () => {
clearSubmenuCloseTimer();
setKeyboardSubmenuFocusRequested(false);
setActiveSubmenuKey(hasSubmenu ? menuKey : null);
};
const pointerGrace = pointerGraceRef.current;
if (pointerGrace && pointerGrace.menuKey !== menuKey && pointerGrace.contains(event)) {
pointerGrace.deferHover(applyHover);
return;
}
pointerGrace?.cancel();
applyHover();
};
const itemVariant: ContextMenuItemVariant = compact
? headerAction ? 'compactHeaderAction' : 'compact'
: 'default';
const itemClassName = contextMenuItemVariants({
sizeVariant,
variant: itemVariant,
disabled,
hoverSuppressed: hoverSuppressed || (activeSubmenuKey !== null && !submenuVisible),
submenuOpen: submenuVisible,
active: resolveMenuItemActiveState(menuItem.id, activated, activeItemIds),
});
const contentNode = (
<span className={getContextMenuContentClassName(sizeVariant)}>
<CustomLabel
value={inputValue}
title={compact ? undefined : menuItem.title}
label={menuItem.label}
icon={menuItem.icon}
onChange={onChange}
/>
{menuItem.shortcut && ` (${menuItem.shortcut})`}
</span>
);
const canExecuteItem = menuItem.type === MenuItemType.BUTTON || menuItem.type === MenuItemType.BUTTON_SELECTOR;
const renderAsContainer = isNonSelectableLabel(menuItem.label);
const SubmenuAffordanceIcon = direction === 'rtl' ? MoreLeftIcon : MoreRightIcon;
const interactiveItemClassName = clsx(itemClassName, isNonHoverableLabel(menuItem.label) && `
hover:univer-bg-transparent
dark:hover:!univer-bg-transparent
`);
return (
<div
ref={menuItemElementRef}
className="univer-relative"
onMouseEnter={onPointerHover}
onMouseMove={onPointerHover}
onMouseLeave={(event) => {
if (submenuVisible) {
if (submenuElementRef.current?.contains(document.activeElement)) {
return;
}
const nextTarget = event.relatedTarget instanceof Node ? event.relatedTarget : null;
if (nextTarget && submenuElementRef.current?.contains(nextTarget)) {
return;
}
if (isContextMenuPointerLeaveTarget(nextTarget, menuItemElementRef.current, rootMenuElement)) {
closeSubmenu();
return;
}
scheduleSubmenuClose();
const submenuRect = submenuElementRef.current?.firstElementChild?.getBoundingClientRect();
if (submenuRect) {
const { clientX: originX, clientY: originY } = event;
const edgeX = submenuPlacement === 'right' ? submenuRect.left : submenuRect.right;
// Protect the diagonal path to the submenu, including when it flips at a viewport edge.
pointerGraceRef.current = {
menuKey,
contains: ({ clientX, clientY }) => {
const progress = (clientX - originX) / (edgeX - originX);
return progress >= 0 && progress <= 1
&& clientY >= originY + (submenuRect.top - originY) * progress
&& clientY <= originY + (submenuRect.bottom - originY) * progress;
},
deferHover: (action) => { pendingHoverActionRef.current = action; },
cancel: clearSubmenuCloseTimer,
};
}
} else {
pointerGraceRef.current?.deferHover(null);
}
}}
>
{renderAsContainer
? (
<div
className={interactiveItemClassName}
aria-disabled={disabled}
>
{contentNode}
{hasSubmenu && (
<SubmenuAffordanceIcon
className={`
${sizeVariant === 'paragraph-t' ? 'univer-size-4' : 'univer-size-3.5'}
univer-text-gray-400
dark:!univer-text-gray-200
`}
/>
)}
</div>
)
: (
<button
ref={menuButtonRef}
type="button"
className={interactiveItemClassName}
disabled={disabled}
title={typeof menuItem.tooltip === 'string' ? localeService.t(menuItem.tooltip) : undefined}
aria-haspopup={hasSubmenu ? 'menu' : undefined}
aria-expanded={hasSubmenu ? submenuVisible : undefined}
aria-controls={hasSubmenu ? submenuId : undefined}
onMouseDownCapture={(event) => {
mouseDownOnInputRef.current = event.target instanceof HTMLInputElement;
}}
onKeyDown={(event) => {
const openDirection = direction === 'rtl' ? 'ArrowLeft' : 'ArrowRight';
if (!hasSubmenu || event.key !== openDirection) {
return;
}
event.preventDefault();
event.stopPropagation();
pointerGraceRef.current?.cancel();
clearSubmenuCloseTimer();
setKeyboardSubmenuFocusRequested(true);
setActiveSubmenuKey(menuKey);
}}
onClick={(event) => {
// Text selection can end outside the input and dispatch a click on this button.
if (event.detail > 0 && mouseDownOnInputRef.current) {
return;
}
pointerGraceRef.current?.cancel();
clearSubmenuCloseTimer();
if (hasSubmenu) {
if (headerAction) {
setKeyboardSubmenuFocusRequested(event.detail === 0);
setActiveSubmenuKey(menuKey);
return;
}
if (canExecuteItem) {
const item = menuItem as IDisplayMenuItem<IMenuButtonItem>;
onOptionSelect?.({
commandId: item.commandId ?? item.id,
params: item.params,
value: inputValue,
id: item.id,
label: menuKey,
});
return;
}
setKeyboardSubmenuFocusRequested(event.detail === 0);
setActiveSubmenuKey(menuKey);
return;
}
if (!canExecuteItem) {
return;
}
const item = menuItem as IDisplayMenuItem<IMenuButtonItem>;
onOptionSelect?.({
commandId: item.commandId ?? item.id,
params: item.params,
value: inputValue,
id: item.id,
label: menuKey,
});
}}
>
{contentNode}
{hasSubmenu && !compact && (
<SubmenuAffordanceIcon
className={`
${sizeVariant === 'paragraph-t' ? 'univer-size-4' : 'univer-size-3.5'}
univer-text-gray-400
dark:!univer-text-gray-200
`}
/>
)}
</button>
)}
{hasSubmenu && submenuVisible && (
submenuPortalContainer
? createPortal(
<div
ref={submenuElementRef}
id={submenuId}
dir={direction}
data-u-context-menu-submenu="true"
className="univer-z-[1080] univer-w-max univer-max-w-[calc(100vw-16px)]"
style={{
position: 'fixed',
left: submenuPosition.left,
top: submenuPosition.top,
paddingLeft: submenuPlacement === 'right' ? submenuVisualGap : 0,
paddingRight: submenuPlacement === 'left' ? submenuVisualGap : 0,
maxHeight: maxMenuHeight,
visibility: submenuPositionReady ? 'visible' : 'hidden',
pointerEvents: submenuPositionReady ? 'auto' : 'none',
}}
onMouseEnter={() => {
clearSubmenuCloseTimer();
onMenuPointerEnter?.();
}}
onMouseLeave={(event) => {
if (submenuElementRef.current?.contains(document.activeElement)) {
return;
}
const nextTarget = event.relatedTarget instanceof Node ? event.relatedTarget : null;
if (nextTarget && menuItemElementRef.current?.contains(nextTarget)) {
return;
}
if (isContextMenuPointerLeaveTarget(nextTarget, menuItemElementRef.current, rootMenuElement)) {
closeSubmenu();
onMenuPointerLeave?.();
return;
}
scheduleSubmenuClose();
}}
onKeyDown={(event) => {
const closeDirection = direction === 'rtl' ? 'ArrowRight' : 'ArrowLeft';
if (event.key !== closeDirection) {
return;
}
event.preventDefault();
event.stopPropagation();
closeSubmenu();
menuButtonRef.current?.focus();
}}
onWheel={(event) => event.stopPropagation()}
>
<div
className={clsx(
getContextMenuSubmenuPanelClassName(sizeVariant),
scrollbarClassName
)}
style={{
maxHeight: maxMenuHeight,
}}
>
{hasSelectionSubmenu && (
<div
className={sizeVariant === 'paragraph-t'
? 'univer-grid univer-gap-2'
: 'univer-grid univer-gap-1'}
>
{selections.map((option, index) => {
const optionKey = `${menuItem.id}-${option.label ?? option.id}-${index}`;
const optionSelected = typeof inputValue !== 'undefined' && String(inputValue) === String(option.value);
const optionSelectable = !isNonSelectableLabel(option.label);
const optionHoverable = !isNonHoverableLabel(option.label);
const optionClassName = clsx(
`
univer-text-gray-900
dark:!univer-text-gray-0
`,
optionSelectable
? sizeVariant === 'paragraph-t'
? `
univer-relative univer-box-border univer-flex univer-min-h-10
univer-w-full univer-items-center univer-rounded-lg
univer-border-none univer-bg-transparent univer-px-3
univer-text-left univer-text-base
rtl:!univer-text-right
`
: `
univer-relative univer-box-border univer-flex univer-min-h-8
univer-w-full univer-items-center univer-rounded-md
univer-border-none univer-bg-transparent univer-px-2
univer-text-left univer-text-sm
rtl:!univer-text-right
`
: `
univer-relative univer-box-border univer-block univer-w-full
univer-border-none univer-bg-transparent univer-p-0
`,
option.disabled
? 'univer-cursor-not-allowed univer-opacity-60'
: optionHoverable && `
univer-cursor-pointer
hover:univer-bg-gray-50
dark:hover:!univer-bg-gray-600
`
);
const optionContentNode = (
<>
{optionSelectable && optionSelected && (
<CheckMarkIcon
className={clsx(
'univer-absolute univer-left-0 univer-text-primary-600',
sizeVariant === 'paragraph-t'
? 'univer-size-5'
: 'univer-size-4'
)}
/>
)}
<span
className={clsx(getContextMenuContentClassName(sizeVariant), optionSelectable && optionSelected && `
univer-pl-4
`)}
>
<CustomLabel
value$={option.value$}
value={option.value}
label={option.label}
icon={option.icon}
onChange={(optionValue) => {
onSubmenuOptionSelect?.({
...option,
value: optionValue,
id: menuItem.id,
label: menuKey,
commandId: option.commandId ?? selectionsCommandId,
});
}}
/>
</span>
</>
);
return (
optionSelectable
? (
<button
key={optionKey}
type="button"
className={optionClassName}
disabled={option.disabled}
onClick={() => {
onSubmenuOptionSelect?.({
...option,
id: menuItem.id,
label: menuKey,
commandId: option.commandId ?? selectionsCommandId,
});
}}
>
{optionContentNode}
</button>
)
: (
<div
key={optionKey}
className={optionClassName}
aria-disabled={option.disabled}
>
{optionContentNode}
</div>
)
);
})}
</div>
)}
{hasSubItemSubmenu && (
<ContextMenuMenu
menuSchemas={subMenuItems}
menuManagerService={menuManagerService}
menuSessionVersion={menuSessionVersion}
submenuPortalContainer={submenuPortalContainer}
rootMenuElement={rootMenuElement}
activeItemIds={activeItemIds}
hiddenItemIds={hiddenItemIds}
hoverSuppressed={hoverSuppressed}
sizeVariant={sizeVariant}
onMenuPointerEnter={onMenuPointerEnter}
onMenuPointerLeave={onMenuPointerLeave}
onOptionSelect={onSubmenuOptionSelect}
maxMenuHeight={maxMenuHeight}
/>
)}
</div>
</div>,
submenuPortalContainer
)
: null
)}
</div>
);
}
function useContextGroupHiddenStates(menuSchemas: IMenuSchema[]) {
const hiddenStates$ = useMemo(() => {
const groupStates = menuSchemas.flatMap((menuSchema) => {
const hiddenObservables = menuSchema.children?.map((childSchema) => childSchema.item?.hidden$ ?? of(false)) ?? [];
return hiddenObservables.length
? [combineLatest(hiddenObservables).pipe(map((values) => [menuSchema.key, values.every(Boolean)] as const))]
: [];
});
return groupStates.length
? merge(...groupStates).pipe(
scan((states, [key, hidden]) => ({ ...states, [key]: hidden }), {} as Record<string, boolean>),
startWith({})
)
: of({});
}, [menuSchemas]);
return useObservable<Record<string, boolean>>(hiddenStates$, {});
}