Skip to content

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.

58.0 KB
Raw Blame
/**
 * 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 { IAccessor, IColorStyle, IStyleData, Nullable, Workbook } from '@univerjs/core';
import type { IMenuButtonItem, IMenuSelectorItem } from '@univerjs/ui';
import {
    BooleanNumber,
    composeStyles,
    DEFAULT_STYLES,
    EDITOR_ACTIVATED,
    FOCUSING_COMMON_DRAWINGS,
    FOCUSING_SHAPE_TEXT_EDITOR,
    FOCUSING_SHEET,
    FontItalic,
    FontWeight,
    HorizontalAlign,
    ICommandService,
    IContextService,
    IUniverInstanceService,
    RANGE_TYPE,
    ThemeService,
    UniverInstanceType,
    VerticalAlign,
    WrapStrategy,
} from '@univerjs/core';
import { SetTextSelectionsOperation } from '@univerjs/docs';
import { EditorColorPicker, SetInlineFormatCommand } from '@univerjs/docs-ui';
import {
    RangeProtectionPermissionEditPoint,
    RangeProtectionPermissionViewPoint,
    ResetBackgroundColorCommand,
    SetBackgroundColorCommand,
    SetColHiddenMutation,
    SetColVisibleMutation,
    SetColWidthCommand,
    SetHorizontalTextAlignCommand,
    SetRangeValuesMutation,
    SetRowHeightCommand,
    SetRowHiddenMutation,
    SetRowVisibleMutation,
    SetSelectedColsVisibleCommand,
    SetSelectedRowsVisibleCommand,
    SetSelectionsOperation,
    SetShrinkToFitCommand,
    SetTextRotationCommand,
    SetTextWrapCommand,
    SetVerticalTextAlignCommand,
    SetWorksheetActiveOperation,
    SetWorksheetColWidthMutation,
    SetWorksheetRowIsAutoHeightCommand,
    SetWorksheetRowIsAutoHeightMutation,
    SheetsSelectionsService,
    WorkbookCopyPermission,
    WorkbookEditablePermission,
    WorksheetCopyPermission,
    WorksheetEditPermission,
    WorksheetSetCellStylePermission,
    WorksheetSetCellValuePermission,
    WorksheetSetColumnStylePermission,
    WorksheetSetRowStylePermission,
} from '@univerjs/sheets';
import {
    CutCommand,
    FONT_FAMILY_COMPONENT,
    FONT_FAMILY_ITEM_COMPONENT,
    getMenuHiddenObservable,
    IClipboardInterfaceService,
    MenuItemType,
} from '@univerjs/ui';
import { combineLatest, combineLatestWith, map, Observable, startWith } from 'rxjs';
import type { LocaleKey } from '../locale/types';
import {
    SheetCopyCommand,
    SheetCutCommand,
    SheetPasteBesidesBorderCommand,
    SheetPasteColWidthCommand,
    SheetPasteCommand,
    SheetPasteFormatCommand,
    SheetPasteValueCommand,
} from '../commands/commands/clipboard.command';
import { HideColConfirmCommand, HideRowConfirmCommand } from '../commands/commands/hide-row-col-confirm.command';
import {
    ResetRangeTextColorCommand,
    SetRangeBoldCommand,
    SetRangeFontFamilyCommand,
    SetRangeItalicCommand,
    SetRangeStrickThroughCommand,
    SetRangeTextColorCommand,
    SetRangeUnderlineCommand,
} from '../commands/commands/inline-format.command';
import {
    SetInfiniteFormatPainterCommand,
    SetOnceFormatPainterCommand,
} from '../commands/commands/set-format-painter.command';
import { SetWorksheetColAutoWidthCommand } from '../commands/commands/set-worksheet-auto-col-width.command';
import { ISheetClipboardService } from '../services/clipboard/clipboard.service';
import { FormatPainterStatus, IFormatPainterService } from '../services/format-painter/format-painter.service';
import { MENU_ITEM_INPUT_COMPONENT } from '../views/menu-item-input/interface';
import { deriveStateFromActiveSheet$, getCurrentRangeDisable$, getObservableWithExclusiveRange$ } from './menu-util';
import { getFontStyleAtCursor } from './utils';

export enum SheetMenuPosition {
    ROW_HEADER_CONTEXT_MENU = 'ROW_HEADER_CONTEXT_MENU',
    COL_HEADER_CONTEXT_MENU = 'COL_HEADER_CONTEXT_MENU',
    SHEET_BAR = 'SHEET_BAR',
    SHEET_FOOTER = 'SHEET_FOOTER',
}

export function FormatPainterMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const formatPainterService = accessor.get(IFormatPainterService);

    return {
        id: SetOnceFormatPainterCommand.id,
        subId: SetInfiniteFormatPainterCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'BrushIcon',
        title: 'sheets-ui.toolbar.formatPainter',
        tooltip: 'sheets-ui.toolbar.formatPainter',
        activated$: new Observable<boolean>((subscriber) => {
            let active = false;

            const status$ = formatPainterService.status$.subscribe((s) => {
                active = s !== FormatPainterStatus.OFF;
                subscriber.next(active);
            });

            subscriber.next(active);

            return () => {
                status$.unsubscribe();
            };
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetCopyPermission, WorksheetEditPermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }, true),
    };
}

export function BoldMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const contextService = accessor.get(IContextService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    return {
        id: SetRangeBoldCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'BoldIcon',
        title: 'sheets-ui.toolbar.bold',
        tooltip: 'sheets-ui.toolbar.bold',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }, true, true),
        activated$: deriveStateFromActiveSheet$(univerInstanceService, false, ({ worksheet }) => new Observable<boolean>((subscriber) => {
            const disposable = commandService.onCommandExecuted((c) => {
                const id = c.id;
                if (id === SetRangeValuesMutation.id || id === SetSelectionsOperation.id || id === SetWorksheetActiveOperation.id) {
                    const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                    let isBold = FontWeight.NORMAL;

                    if (primary != null) {
                        const range = worksheet.getRange(primary.startRow, primary.startColumn);
                        isBold = range?.getFontWeight();
                    }

                    subscriber.next(isBold === FontWeight.BOLD);
                }

                if (
                    (id === SetTextSelectionsOperation.id || id === SetInlineFormatCommand.id) &&
                    contextService.getContextValue(EDITOR_ACTIVATED) &&
                    (contextService.getContextValue(FOCUSING_SHEET) || contextService.getContextValue(FOCUSING_SHAPE_TEXT_EDITOR))
                ) {
                    const textRun = getFontStyleAtCursor(accessor);
                    if (textRun == null) {
                        return;
                    }

                    const bl = textRun.ts?.bl;
                    subscriber.next(bl === BooleanNumber.TRUE);
                }
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            if (!worksheet) {
                subscriber.next(false);
                return;
            }

            let isBold = FontWeight.NORMAL;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                isBold = range?.getFontWeight();
            }
            subscriber.next(isBold === FontWeight.BOLD);

            return disposable.dispose;
        })),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function ItalicMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);
    const contextService = accessor.get(IContextService);

    return {
        id: SetRangeItalicCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'ItalicIcon',
        title: 'sheets-ui.toolbar.italic',
        tooltip: 'sheets-ui.toolbar.italic',
        disabled$: getCurrentRangeDisable$(
            accessor,
            {
                workbookTypes: [WorkbookEditablePermission],
                worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
                rangeTypes: [RangeProtectionPermissionEditPoint],
            },
            true,
            true
        ),
        activated$: deriveStateFromActiveSheet$(univerInstanceService, false, ({ worksheet }) => new Observable<boolean>((subscriber) => {
            const disposable = commandService.onCommandExecuted((c) => {
                const id = c.id;
                if (id === SetRangeValuesMutation.id || id === SetSelectionsOperation.id || id === SetWorksheetActiveOperation.id) {
                    const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                    let isItalic = FontItalic.NORMAL;
                    if (primary != null) {
                        const range = worksheet.getRange(primary.startRow, primary.startColumn);
                        isItalic = range?.getFontStyle();
                    }

                    subscriber.next(isItalic === FontItalic.ITALIC);
                }

                if (
                    (id === SetTextSelectionsOperation.id || id === SetInlineFormatCommand.id) &&
                    contextService.getContextValue(EDITOR_ACTIVATED) &&
                    (contextService.getContextValue(FOCUSING_SHEET) || contextService.getContextValue(FOCUSING_SHAPE_TEXT_EDITOR))
                ) {
                    const textRun = getFontStyleAtCursor(accessor);
                    if (textRun == null) return;

                    const it = textRun.ts?.it;
                    subscriber.next(it === BooleanNumber.TRUE);
                }
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            let isItalic = FontItalic.NORMAL;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                isItalic = range?.getFontStyle();
            }

            subscriber.next(isItalic === FontItalic.ITALIC);
            return disposable.dispose;
        })),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function UnderlineMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);
    const contextService = accessor.get(IContextService);

    return {
        id: SetRangeUnderlineCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'UnderlineIcon',
        title: 'sheets-ui.toolbar.underline',
        tooltip: 'sheets-ui.toolbar.underline',
        activated$: deriveStateFromActiveSheet$(univerInstanceService, false, ({ worksheet }) => new Observable<boolean>((subscriber) => {
            const disposable = commandService.onCommandExecuted((c) => {
                const id = c.id;
                if (id === SetRangeValuesMutation.id || id === SetSelectionsOperation.id || id === SetWorksheetActiveOperation.id) {
                    const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                    let isUnderline;
                    if (primary != null) {
                        const range = worksheet.getRange(primary.startRow, primary.startColumn);
                        isUnderline = range?.getUnderline();
                    }

                    subscriber.next(!!(isUnderline && isUnderline.s));
                }

                if (
                    (id === SetTextSelectionsOperation.id || id === SetInlineFormatCommand.id) &&
                    contextService.getContextValue(EDITOR_ACTIVATED) &&
                    (contextService.getContextValue(FOCUSING_SHEET) || contextService.getContextValue(FOCUSING_SHAPE_TEXT_EDITOR))
                ) {
                    const textRun = getFontStyleAtCursor(accessor);
                    if (textRun == null) return;

                    const ul = textRun.ts?.ul;
                    subscriber.next(ul?.s === BooleanNumber.TRUE);
                }
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            let isUnderline;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                isUnderline = range?.getUnderline();
            }

            subscriber.next(!!(isUnderline && isUnderline.s));
            return disposable.dispose;
        })),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }, true, true),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function StrikeThroughMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);
    const contextService = accessor.get(IContextService);

    return {
        id: SetRangeStrickThroughCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'StrikethroughIcon',
        title: 'sheets-ui.toolbar.strikethrough',
        tooltip: 'sheets-ui.toolbar.strikethrough',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }, true, true),
        activated$: deriveStateFromActiveSheet$(univerInstanceService, false, ({ worksheet }) => new Observable<boolean>((subscriber) => {
            const disposable = commandService.onCommandExecuted((c) => {
                const id = c.id;
                if (id === SetRangeValuesMutation.id || id === SetSelectionsOperation.id || id === SetWorksheetActiveOperation.id) {
                    const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                    let st;
                    if (primary != null) {
                        const range = worksheet.getRange(primary.startRow, primary.startColumn);
                        st = range?.getStrikeThrough();
                    }

                    subscriber.next(!!(st && st.s));
                }

                if (
                    (id === SetTextSelectionsOperation.id || id === SetInlineFormatCommand.id) &&
                    contextService.getContextValue(EDITOR_ACTIVATED) &&
                    (contextService.getContextValue(FOCUSING_SHEET) || contextService.getContextValue(FOCUSING_SHAPE_TEXT_EDITOR))
                ) {
                    const textRun = getFontStyleAtCursor(accessor);

                    if (textRun == null) {
                        return;
                    }

                    const st = textRun.ts?.st;

                    subscriber.next(st?.s === BooleanNumber.TRUE);
                }
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            let st;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                st = range?.getStrikeThrough();
            }

            subscriber.next(!!(st && st.s));
            return disposable.dispose;
        })),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function FontFamilySelectorMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey, string> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    const defaultValue = DEFAULT_STYLES.ff;
    const disabled$ = getCurrentRangeDisable$(accessor, {
        workbookTypes: [WorkbookEditablePermission],
        worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
        rangeTypes: [RangeProtectionPermissionEditPoint],
    }, true, true);

    return {
        id: SetRangeFontFamilyCommand.id,
        tooltip: 'sheets-ui.toolbar.font',
        type: MenuItemType.SELECTOR,
        label: {
            name: FONT_FAMILY_COMPONENT,
            props: {
                id: SetRangeFontFamilyCommand.id,
                disabled$,
            },
        },
        selections: [{
            label: {
                name: FONT_FAMILY_ITEM_COMPONENT,
                hoverable: false,
                selectable: false,
                props: {
                    id: SetRangeFontFamilyCommand.id,
                },
            },
        }],
        disabled$,
        value$: deriveStateFromActiveSheet$(univerInstanceService, defaultValue, ({ worksheet }) => new Observable((subscriber) => {
            const updateSheet = () => {
                let ff = defaultValue;

                const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                if (primary != null) {
                    const cell = worksheet.getCellStyle(primary.startRow, primary.startColumn);
                    const defaultStyle = worksheet.getDefaultCellStyleInternal();
                    const rowStyle = worksheet.getRowStyle(primary.startRow);
                    const colStyle = worksheet.getColumnStyle(primary.startColumn);
                    const style = composeStyles(defaultStyle, rowStyle, colStyle, cell);
                    if (style.ff) {
                        ff = style.ff;
                    }
                }

                subscriber.next(ff);
            };

            const disposable = commandService.onCommandExecuted((c) => {
                const id = c.id;
                if (id === SetRangeValuesMutation.id || id === SetSelectionsOperation.id || id === SetWorksheetActiveOperation.id) {
                    updateSheet();
                }

                if (
                    (id === SetTextSelectionsOperation.id || id === SetInlineFormatCommand.id) &&
                    accessor.get(IContextService).getContextValue(EDITOR_ACTIVATED) &&
                    (accessor.get(IContextService).getContextValue(FOCUSING_SHEET) || accessor.get(IContextService).getContextValue(FOCUSING_SHAPE_TEXT_EDITOR))
                ) {
                    const textRun = getFontStyleAtCursor(accessor);
                    if (textRun != null) {
                        const ff = (textRun.ts?.ff ?? defaultValue);
                        subscriber.next(ff);
                    }
                }
            });

            updateSheet();
            return disposable.dispose;
        })),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function ResetTextColorMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: ResetRangeTextColorCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.toolbar.resetColor',
        icon: 'NoColorDoubleIcon',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }, true, true),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function TextColorSelectorMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey, string, string | undefined> {
    const commandService = accessor.get(ICommandService);
    const themeService = accessor.get(ThemeService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    return {
        id: SetRangeTextColorCommand.id,
        icon: 'FontColorDoubleIcon',
        tooltip: 'sheets-ui.toolbar.textColor.main',
        type: MenuItemType.BUTTON_SELECTOR,
        selections: [
            {
                label: {
                    name: EditorColorPicker.componentKey,
                    hoverable: false,
                    selectable: false,
                },
                value$: new Observable<string>((subscriber) => {
                    const defaultValue = themeService.getColorFromTheme('gray.900');
                    const { isAllValuesSame, value: currentValue } = selectionManagerService.getCellStylesProperty('cl');

                    if (isAllValuesSame) {
                        subscriber.next((currentValue as Nullable<IColorStyle>)?.rgb ?? defaultValue);
                    } else {
                        subscriber.next(defaultValue);
                    }
                }),
            },
        ],
        value$: new Observable<string>((subscriber) => {
            const defaultValue = themeService.getColorFromTheme('gray.900');
            const disposable = commandService.onCommandExecuted((c) => {
                if (c.id === SetRangeTextColorCommand.id) {
                    const color = (c.params as { value: string }).value;
                    subscriber.next(color ?? defaultValue);
                }
            });

            subscriber.next(defaultValue);
            return disposable.dispose;
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }, true, true),
    };
}

export function ResetBackgroundColorMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: ResetBackgroundColorCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.toolbar.resetColor',
        icon: 'NoColorDoubleIcon',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export function BackgroundColorSelectorMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey, string, string | undefined> {
    const commandService = accessor.get(ICommandService);
    const themeService = accessor.get(ThemeService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    return {
        id: SetBackgroundColorCommand.id,
        tooltip: 'sheets-ui.toolbar.fillColor.main',
        type: MenuItemType.BUTTON_SELECTOR,
        icon: 'PaintBucketDoubleIcon',
        selections: [
            {
                label: {
                    name: EditorColorPicker.componentKey,
                    hoverable: false,
                    selectable: false,
                },
                value$: new Observable<string>((subscriber) => {
                    const defaultValue = themeService.getColorFromTheme('primary.600');
                    const { isAllValuesSame, value: currentValue } = selectionManagerService.getCellStylesProperty('bg');

                    if (isAllValuesSame) {
                        subscriber.next((currentValue as Nullable<IColorStyle>)?.rgb ?? defaultValue);
                    } else {
                        subscriber.next(defaultValue);
                    }
                }),
            },
        ],
        value$: new Observable<string>((subscriber) => {
            const defaultValue = themeService.getColorFromTheme('primary.600');
            const disposable = commandService.onCommandExecuted((c) => {
                if (c.id === SetBackgroundColorCommand.id) {
                    const color = (c.params as { value: string }).value;
                    subscriber.next(color ?? defaultValue);
                }
            });

            subscriber.next(defaultValue);
            return disposable.dispose;
        }),
        hidden$: combineLatest([
            getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
            accessor.get(IContextService).subscribeContextValue$(FOCUSING_COMMON_DRAWINGS).pipe(startWith(false)),
        ]).pipe(map(([hidden, focusingDrawing]) => hidden || focusingDrawing)),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export const HORIZONTAL_ALIGN_CHILDREN = [
    {
        label: 'sheets-ui.align.left',
        icon: 'LeftJustifyingIcon',
        value: HorizontalAlign.LEFT,
    },
    {
        label: 'sheets-ui.align.center',
        icon: 'HorizontallyIcon',
        value: HorizontalAlign.CENTER,
    },
    {
        label: 'sheets-ui.align.right',
        icon: 'RightJustifyingIcon',
        value: HorizontalAlign.RIGHT,
    },
];

export function HorizontalAlignMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey, HorizontalAlign> {
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    const workbook = univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET);

    const defaultStyle = workbook?.getActiveSheet().getDefaultCellStyleInternal();
    const defaultValue = defaultStyle?.ht ?? HorizontalAlign.LEFT;

    return {
        id: SetHorizontalTextAlignCommand.id,
        icon: HORIZONTAL_ALIGN_CHILDREN.find((child) => child.value === defaultValue)?.icon,
        tooltip: 'sheets-ui.toolbar.horizontalAlignMode.main',
        type: MenuItemType.SELECTOR,
        selections: HORIZONTAL_ALIGN_CHILDREN,
        value$: deriveStateFromActiveSheet$(univerInstanceService, defaultValue, ({ worksheet }) => new Observable<HorizontalAlign>((subscriber) => {
            const disposable = accessor.get(ICommandService).onCommandExecuted((c) => {
                const id = c.id;
                if (id !== SetHorizontalTextAlignCommand.id && id !== SetSelectionsOperation.id && id !== SetWorksheetActiveOperation.id) {
                    return;
                }

                const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                let ht;
                if (primary != null) {
                    const range = worksheet.getRange(primary.startRow, primary.startColumn);
                    const defaultCellStyle = workbook?.getActiveSheet().getComposedCellStyle(primary.startRow, primary.startColumn);
                    ht = defaultCellStyle?.ht ?? range?.getHorizontalAlignment();
                }

                subscriber.next(ht ?? defaultValue);
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            let ht;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                const defaultCellStyle = workbook?.getActiveSheet().getComposedCellStyle(primary.startRow, primary.startColumn);
                ht = defaultCellStyle?.ht ?? range?.getHorizontalAlignment();
            }

            subscriber.next(ht ?? defaultValue);

            return disposable.dispose;
        })),
        hidden$: combineLatest([
            getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
            accessor.get(IContextService).subscribeContextValue$(FOCUSING_COMMON_DRAWINGS).pipe(startWith(false)),
        ]).pipe(map(([hidden, focusingDrawing]) => hidden || focusingDrawing)),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export const VERTICAL_ALIGN_CHILDREN = [
    {
        label: 'sheets-ui.align.top',
        icon: 'AlignTopIcon',
        value: VerticalAlign.TOP,
    },
    {
        label: 'sheets-ui.align.middle',
        icon: 'VerticalCenterIcon',
        value: VerticalAlign.MIDDLE,
    },
    {
        label: 'sheets-ui.align.bottom',
        icon: 'AlignBottomIcon',
        value: VerticalAlign.BOTTOM,
    },
];

export function VerticalAlignMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey, VerticalAlign> {
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    const workbook = univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET);

    const defaultStyle = workbook?.getActiveSheet().getDefaultCellStyleInternal();
    const defaultValue = defaultStyle?.vt ?? VerticalAlign.BOTTOM;

    return {
        id: SetVerticalTextAlignCommand.id,
        icon: VERTICAL_ALIGN_CHILDREN.find((child) => child.value === defaultValue)?.icon,
        tooltip: 'sheets-ui.toolbar.verticalAlignMode.main',
        type: MenuItemType.SELECTOR,
        selections: VERTICAL_ALIGN_CHILDREN,
        value$: deriveStateFromActiveSheet$(univerInstanceService, defaultValue, ({ worksheet }) => new Observable<VerticalAlign>((subscriber) => {
            const disposable = accessor.get(ICommandService).onCommandExecuted((c) => {
                const id = c.id;
                if (id !== SetVerticalTextAlignCommand.id && id !== SetSelectionsOperation.id && id !== SetWorksheetActiveOperation.id) {
                    return;
                }

                const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                let vt;
                if (primary != null) {
                    const range = worksheet.getRange(primary.startRow, primary.startColumn);
                    const defaultCellStyle = workbook?.getActiveSheet().getComposedCellStyle(primary.startRow, primary.startColumn);
                    vt = defaultCellStyle?.vt ?? range?.getVerticalAlignment();
                }

                subscriber.next(vt ?? defaultValue);
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            let vt;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                const defaultCellStyle = workbook?.getActiveSheet().getComposedCellStyle(primary.startRow, primary.startColumn);
                vt = defaultCellStyle?.vt ?? range?.getVerticalAlignment();
            }

            subscriber.next(vt ?? defaultValue);

            return disposable.dispose;
        })),
        hidden$: combineLatest([
            getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
            accessor.get(IContextService).subscribeContextValue$(FOCUSING_COMMON_DRAWINGS).pipe(startWith(false)),
        ]).pipe(map(([hidden, focusingDrawing]) => hidden || focusingDrawing)),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export const TEXT_WRAP_CHILDREN = [
    {
        label: 'sheets-ui.textWrap.overflow',
        icon: 'OverflowIcon',
        value: WrapStrategy.OVERFLOW,
    },
    {
        label: 'sheets-ui.textWrap.wrap',
        icon: 'AutowrapIcon',
        value: WrapStrategy.WRAP,
    },
    {
        label: 'sheets-ui.textWrap.clip',
        icon: 'TruncationIcon',
        value: WrapStrategy.CLIP,
    },
];

export function WrapTextMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey, WrapStrategy> {
    const selectionManagerService = accessor.get(SheetsSelectionsService);
    const univerInstanceService = accessor.get(IUniverInstanceService);

    const workbook = univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET);

    const defaultStyle = workbook?.getActiveSheet().getDefaultCellStyleInternal();
    const defaultValue = defaultStyle?.tb ?? WrapStrategy.OVERFLOW;

    return {
        id: SetTextWrapCommand.id,
        tooltip: 'sheets-ui.toolbar.textWrapMode.main',
        icon: TEXT_WRAP_CHILDREN.find((child) => child.value === defaultValue)?.icon,
        type: MenuItemType.SELECTOR,
        selections: TEXT_WRAP_CHILDREN,
        value$: deriveStateFromActiveSheet$<WrapStrategy>(univerInstanceService, defaultValue, ({ worksheet }) => new Observable((subscriber) => {
            const disposable = accessor.get(ICommandService).onCommandExecuted((c) => {
                const id = c.id;
                if (id !== SetRangeValuesMutation.id && id !== SetSelectionsOperation.id && id !== SetWorksheetActiveOperation.id) {
                    return;
                }

                const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                let tb;
                if (primary != null) {
                    const range = worksheet.getRange(primary.startRow, primary.startColumn);
                    const defaultCellStyle = workbook?.getActiveSheet().getComposedCellStyle(primary.startRow, primary.startColumn);
                    tb = defaultCellStyle?.tb ?? range?.getWrapStrategy();
                }

                subscriber.next(tb ?? defaultValue);
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            let tb;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                const defaultCellStyle = workbook?.getActiveSheet().getComposedCellStyle(primary.startRow, primary.startColumn);
                tb = defaultCellStyle?.tb ?? range?.getWrapStrategy();
            }

            subscriber.next(tb ?? defaultValue);

            return disposable.dispose;
        })),
        hidden$: combineLatest([
            getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
            accessor.get(IContextService).subscribeContextValue$(FOCUSING_COMMON_DRAWINGS).pipe(startWith(false)),
        ]).pipe(map(([hidden, focusingDrawing]) => hidden || focusingDrawing)),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export function ShrinkToFitMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);
    const style$ = deriveStateFromActiveSheet$<IStyleData>(univerInstanceService, {}, ({ worksheet }) => new Observable((subscriber) => {
        const update = () => {
            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            subscriber.next(primary != null ? worksheet.getComposedCellStyle(primary.startRow, primary.startColumn) ?? {} : {});
        };
        const disposable = commandService.onCommandExecuted((command) => {
            if ([SetRangeValuesMutation.id, SetSelectionsOperation.id, SetWorksheetActiveOperation.id].includes(command.id)) {
                update();
            }
        });

        update();
        return disposable.dispose;
    }));

    return {
        id: SetShrinkToFitCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'ShrinkToFitIcon',
        title: 'sheets-ui.toolbar.shrinkToFit',
        tooltip: 'sheets-ui.toolbar.shrinkToFit',
        activated$: style$.pipe(map((style) => style.stf === BooleanNumber.TRUE && style.tb !== WrapStrategy.WRAP)),
        disabled$: combineLatest([
            getCurrentRangeDisable$(accessor, {
                workbookTypes: [WorkbookEditablePermission],
                worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
                rangeTypes: [RangeProtectionPermissionEditPoint],
            }),
            style$,
        ]).pipe(map(([disabled, style]) => disabled || style.tb === WrapStrategy.WRAP)),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export const TEXT_ROTATE_CHILDREN = [
    {
        label: 'sheets-ui.textRotate.none',
        icon: 'NoRotationIcon',
        value: 0,
    },
    {
        label: 'sheets-ui.textRotate.angleUp',
        icon: 'LeftRotationFortyFiveDegreesIcon',
        value: -45,
    },
    {
        label: 'sheets-ui.textRotate.angleDown',
        icon: 'RightRotationFortyFiveDegreesIcon',
        value: 45,
    },
    {
        label: 'sheets-ui.textRotate.vertical',
        icon: 'VerticalTextIcon',
        value: 'v',
    },
    {
        label: 'sheets-ui.textRotate.rotationUp',
        icon: 'LeftRotationNinetyDegreesIcon',
        value: -90,
    },
    {
        label: 'sheets-ui.textRotate.rotationDown',
        icon: 'RightRotationNinetyDegreesIcon',
        value: 90,
    },
];

export function TextRotateMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey, number | string> {
    const selectionManagerService = accessor.get(SheetsSelectionsService);
    const univerInstanceService = accessor.get(IUniverInstanceService);

    const defaultValue = 0;

    return {
        id: SetTextRotationCommand.id,
        tooltip: 'sheets-ui.toolbar.textRotateMode.main',
        icon: TEXT_ROTATE_CHILDREN[0].icon,
        type: MenuItemType.SELECTOR,
        selections: TEXT_ROTATE_CHILDREN,
        value$: deriveStateFromActiveSheet$(univerInstanceService, defaultValue, ({ worksheet }) => new Observable<number | string>((subscriber) => {
            const disposable = accessor.get(ICommandService).onCommandExecuted((c) => {
                const id = c.id;
                if (id !== SetTextRotationCommand.id && id !== SetSelectionsOperation.id && id !== SetWorksheetActiveOperation.id) {
                    return;
                }

                const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                let tr;
                if (primary != null) {
                    const range = worksheet.getRange(primary.startRow, primary.startColumn);
                    tr = range?.getTextRotation();
                }

                if (tr?.v === BooleanNumber.TRUE) {
                    subscriber.next('v');
                } else {
                    subscriber.next((tr && tr.a) ?? defaultValue);
                }
            });

            const primary = selectionManagerService.getCurrentLastSelection()?.primary;
            let tr;
            if (primary != null) {
                const range = worksheet.getRange(primary.startRow, primary.startColumn);
                tr = range?.getTextRotation();
            }

            if (tr?.v === BooleanNumber.TRUE) {
                subscriber.next('v');
            } else {
                subscriber.next((tr && tr.a) ?? defaultValue);
            }

            return disposable.dispose;
        })),
        hidden$: combineLatest([
            getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
            accessor.get(IContextService).subscribeContextValue$(FOCUSING_COMMON_DRAWINGS).pipe(startWith(false)),
        ]).pipe(map(([hidden, focusingDrawing]) => hidden || focusingDrawing)),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

// #region - copy cut paste
// TODO@wzhudev: maybe we should move these menu factory to @univerjs/ui

export function menuClipboardDisabledObservable(injector: IAccessor): Observable<boolean> {
    return new Observable((subscriber) => {
        const clipboardInterfaceService = injector.get(IClipboardInterfaceService);
        const supportClipboard = clipboardInterfaceService.supportClipboard;

        const sheetClipboardService = injector.get(ISheetClipboardService);
        const subscription = sheetClipboardService.copyContentCache().lastCopyId$.subscribe((lastCopyId) => {
            subscriber.next(!supportClipboard && !lastCopyId);
        });

        subscriber.next(!supportClipboard);

        return () => subscription.unsubscribe();
    });
}

export function CopyMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: SheetCopyCommand.name,
        commandId: SheetCopyCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.rightClick.copy',
        icon: 'CopyDoubleIcon',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookCopyPermission],
            worksheetTypes: [WorksheetCopyPermission],
            rangeTypes: [RangeProtectionPermissionViewPoint],
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function CutMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: SheetCutCommand.name,
        commandId: CutCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.rightClick.cut',
        icon: 'CutIcon',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookCopyPermission, WorkbookEditablePermission],
            worksheetTypes: [WorksheetCopyPermission, WorksheetEditPermission],
            rangeTypes: [RangeProtectionPermissionViewPoint, RangeProtectionPermissionEditPoint],
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function PasteMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: SheetPasteCommand.name,
        commandId: SheetPasteCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.rightClick.paste',
        icon: 'PasteSpecialDoubleIcon',
        disabled$: menuClipboardDisabledObservable(accessor).pipe(
            combineLatestWith(getCurrentRangeDisable$(accessor, {
                rangeTypes: [RangeProtectionPermissionEditPoint],
                worksheetTypes: [WorksheetEditPermission, WorksheetSetCellStylePermission, WorksheetSetCellValuePermission],
                workbookTypes: [WorkbookEditablePermission],
            })),
            map(([d1, d2]) => d1 || d2)
        ),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

// Right click menu - Copy Special
export const COPY_SPECIAL_MENU_ID = 'sheet.menu.copy-special';
export function CopySpacialMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey> {
    return {
        id: COPY_SPECIAL_MENU_ID,
        type: MenuItemType.SUBITEMS,
        icon: 'CopyDoubleIcon',
        title: 'sheets-ui.rightClick.copySpecial',
        hidden$: getObservableWithExclusiveRange$(accessor, getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET)),
    };
}

// Right click menu - Paste Special
export const PASTE_SPECIAL_MENU_ID = 'sheet.menu.paste-special';
export function PasteSpacialMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey> {
    return {
        id: PASTE_SPECIAL_MENU_ID,
        type: MenuItemType.SUBITEMS,
        icon: 'PasteSpecialDoubleIcon',
        title: 'sheets-ui.rightClick.pasteSpecial',
        hidden$: getObservableWithExclusiveRange$(accessor, getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET)),
    };
}

export const PASTE_RIBBON_MENU_ID = 'sheet.menu.paste';
export function PasteRibbonMenuItemFactory(accessor: IAccessor): IMenuSelectorItem<LocaleKey> {
    return {
        ...PasteSpacialMenuItemFactory(accessor),
        id: PASTE_RIBBON_MENU_ID,
        icon: 'DocPasteOptionsIcon',
        title: 'sheets-ui.rightClick.paste',
        hidden$: combineLatest([
            getObservableWithExclusiveRange$(accessor, getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET)),
            accessor.get(IContextService).subscribeContextValue$(FOCUSING_SHAPE_TEXT_EDITOR).pipe(startWith(false)),
        ]).pipe(map(([hidden, editing]) => hidden || editing)),
    };
}

export function PasteValueMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey, string> {
    return {
        id: SheetPasteValueCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.rightClick.pasteValue',
        disabled$: menuClipboardDisabledObservable(accessor).pipe(
            combineLatestWith(getCurrentRangeDisable$(accessor, {
                rangeTypes: [RangeProtectionPermissionEditPoint],
                worksheetTypes: [WorksheetSetCellValuePermission, WorksheetEditPermission],
                workbookTypes: [WorkbookEditablePermission],
            })),
            map(([d1, d2]) => d1 || d2)
        ),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function PasteFormatMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey, string> {
    return {
        id: SheetPasteFormatCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.rightClick.pasteFormat',
        disabled$: menuClipboardDisabledObservable(accessor).pipe(
            combineLatestWith(getCurrentRangeDisable$(accessor, {
                rangeTypes: [RangeProtectionPermissionEditPoint],
                worksheetTypes: [WorksheetSetCellStylePermission, WorksheetEditPermission],
                workbookTypes: [WorkbookEditablePermission],
            })),
            map(([d1, d2]) => d1 || d2)
        ),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function PasteColWidthMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey, string> {
    return {
        id: SheetPasteColWidthCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.rightClick.pasteColWidth',
        disabled$: menuClipboardDisabledObservable(accessor).pipe(
            combineLatestWith(getCurrentRangeDisable$(accessor, {
                rangeTypes: [RangeProtectionPermissionEditPoint],
                worksheetTypes: [WorksheetSetColumnStylePermission, WorksheetEditPermission],
                workbookTypes: [WorkbookEditablePermission],
            })),
            map(([d1, d2]) => d1 || d2)
        ),
    };
}

export function PasteBesidesBorderMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey, string> {
    return {
        id: SheetPasteBesidesBorderCommand.id,
        type: MenuItemType.BUTTON,
        title: 'sheets-ui.rightClick.pasteBesidesBorder',
        disabled$: menuClipboardDisabledObservable(accessor).pipe(
            combineLatestWith(getCurrentRangeDisable$(accessor, {
                rangeTypes: [RangeProtectionPermissionEditPoint],
                worksheetTypes: [
                    WorksheetEditPermission,
                    WorksheetSetCellStylePermission,
                    WorksheetSetCellValuePermission,
                    WorksheetSetRowStylePermission,
                    WorksheetSetColumnStylePermission,
                ],
                workbookTypes: [WorkbookEditablePermission],
            })),
            map(([d1, d2]) => d1 || d2)
        ),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

//#endregion

export function FitContentMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: SetWorksheetRowIsAutoHeightCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'AutoHeightDoubleIcon',
        title: 'sheets-ui.rightClick.fitContent',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetSetRowStylePermission, WorksheetEditPermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function ColAutoWidthMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: SetWorksheetColAutoWidthCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'AutoWidthDoubleIcon',
        title: 'sheets-ui.rightClick.fitContent',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetSetRowStylePermission, WorksheetEditPermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function HideRowMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: HideRowConfirmCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'HideDoubleIcon',
        title: 'sheets-ui.rightClick.hideSelectedRow',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetSetRowStylePermission, WorksheetEditPermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function HideColMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    return {
        id: HideColConfirmCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'HideDoubleIcon',
        title: 'sheets-ui.rightClick.hideSelectedColumn',
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetColumnStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
        hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
    };
}

export function ShowRowMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    const commandService = accessor.get(ICommandService);

    const affectedCommands = [SetSelectionsOperation, SetRowHiddenMutation, SetRowVisibleMutation].map((c) => c.id);

    return {
        id: SetSelectedRowsVisibleCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'EyeIcon',
        title: 'sheets-ui.rightClick.showHideRow',
        hidden$: deriveStateFromActiveSheet$(univerInstanceService, true, ({ worksheet }) => new Observable((subscriber) => {
            function hasHiddenRowsInSelections(): boolean {
                const rowRanges = selectionManagerService.getCurrentSelections()?.map((s) => s.range).filter((r) => r.rangeType === RANGE_TYPE.ROW);
                return !!rowRanges?.some((range) => {
                    for (let r = range.startRow; r <= range.endRow; r++) {
                        if (!worksheet.getRowRawVisible(r)) return true; // should not take filtered out rows into account
                    }

                    return false;
                });
            }

            const disposable = commandService.onCommandExecuted((command) => {
                if (affectedCommands.findIndex((c) => c === command.id) !== -1) subscriber.next(!hasHiddenRowsInSelections());
            });

            // it only shows when selected area has hidden rows
            subscriber.next(!hasHiddenRowsInSelections());
            return () => disposable.dispose();
        })),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetRowStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export function ShowColMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey> {
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);
    const commandService = accessor.get(ICommandService);
    const affectedCommands = [SetSelectionsOperation, SetColHiddenMutation, SetColVisibleMutation].map((c) => c.id);

    return {
        id: SetSelectedColsVisibleCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'EyeIcon',
        title: 'sheets-ui.rightClick.showHideColumn',
        hidden$: deriveStateFromActiveSheet$(univerInstanceService, true, ({ worksheet }) => new Observable((subscriber) => {
            function hasHiddenColsInSelections(): boolean {
                const colRanges = selectionManagerService.getCurrentSelections()?.map((s) => s.range).filter((r) => r.rangeType === RANGE_TYPE.COLUMN);
                if (!colRanges || colRanges.length === 0) return false;

                return !!colRanges.some((range) => {
                    for (let r = range.startColumn; r <= range.endColumn; r++) {
                        if (!worksheet.getColVisible(r)) return true;
                    }

                    return false;
                });
            }

            const disposable = commandService.onCommandExecuted((commandInfo) => {
                if (affectedCommands.findIndex((c) => c === commandInfo.id) !== -1) subscriber.next(!hasHiddenColsInSelections());
            });

            subscriber.next(!hasHiddenColsInSelections());
            return () => disposable.dispose();
        })),
        disabled$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetSetColumnStylePermission, WorksheetEditPermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export function SetRowHeightMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey, number> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    const min = 0;

    return {
        id: SetRowHeightCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'AdjustHeightDoubleIcon',
        label: {
            name: MENU_ITEM_INPUT_COMPONENT,
            props: {
                prefix: 'sheets-ui.rightClick.rowHeight',
                suffix: 'px',
                min,
                max: 1000,
            },
        },
        value$: deriveStateFromActiveSheet$(univerInstanceService, min, ({ worksheet }) => new Observable((subscriber) => {
            function update() {
                const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                const rowHeight = primary ? worksheet.getRowHeight(primary.startRow) : worksheet.getConfig().defaultRowHeight;
                subscriber.next(rowHeight);
            }

            const disposable = commandService.onCommandExecuted((c) => {
                const id = c.id;
                if (id === SetRangeValuesMutation.id || id === SetSelectionsOperation.id || id === SetWorksheetRowIsAutoHeightMutation.id) {
                    return update();
                }
            });

            update();
            return disposable.dispose;
        })),
        hidden$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetRowStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}

export function SetColWidthMenuItemFactory(accessor: IAccessor): IMenuButtonItem<LocaleKey, number> {
    const commandService = accessor.get(ICommandService);
    const univerInstanceService = accessor.get(IUniverInstanceService);
    const selectionManagerService = accessor.get(SheetsSelectionsService);

    const min = 0;

    return {
        id: SetColWidthCommand.id,
        type: MenuItemType.BUTTON,
        icon: 'AdjustWidthDoubleIcon',
        label: {
            name: MENU_ITEM_INPUT_COMPONENT,
            props: {
                prefix: 'sheets-ui.rightClick.columnWidth',
                suffix: 'px',
                min,
                max: 1000,
            },
        },
        value$: deriveStateFromActiveSheet$(univerInstanceService, min, ({ worksheet }) => new Observable((subscriber) => {
            function update() {
                const primary = selectionManagerService.getCurrentLastSelection()?.primary;
                const colWidth = primary ? worksheet.getColumnWidth(primary.startColumn) : worksheet.getConfig().defaultColumnWidth;

                subscriber.next(colWidth);
            }

            const disposable = commandService.onCommandExecuted((c) => {
                const id = c.id;
                if (id === SetRangeValuesMutation.id || id === SetSelectionsOperation.id || id === SetWorksheetColWidthMutation.id) {
                    return update();
                }
            });

            update();
            return disposable.dispose;
        })),
        hidden$: getCurrentRangeDisable$(accessor, {
            workbookTypes: [WorkbookEditablePermission],
            worksheetTypes: [WorksheetEditPermission, WorksheetSetColumnStylePermission],
            rangeTypes: [RangeProtectionPermissionEditPoint],
        }),
    };
}