TypeScript
"use client"
import * as React from "react"
import {
useXlsxViewer,
useXlsxViewerController,
useXlsxViewerEditing,
useXlsxViewerSelection,
useXlsxViewerZoom,
XlsxViewer,
XlsxViewerProvider,
type XlsxCellAlignmentInput,
type XlsxCellBorderEdgeInput,
type XlsxCellRange,
type XlsxCellStyleInput,
type XlsxSheetData,
type XlsxTableHeaderMenuRenderProps,
} from "@extend-ai/react-xlsx"
import type { RegistryIconProps } from "@/lib/registry-icon-props"
import { cn } from "@/lib/utils"
import { Button } from "@/components/ui/button"
import { ColorPicker, ColorPickerPanel } from "@/components/ui/color-picker"
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuItem,
DropdownMenuSeparator,
DropdownMenuSub,
DropdownMenuSubContent,
DropdownMenuSubTrigger,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import { Group, GroupSeparator, GroupText } from "@/components/ui/group"
import { Input } from "@/components/ui/input"
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue,
} from "@/components/ui/select"
import { Separator } from "@/components/ui/separator"
import { Spinner } from "@/components/ui/spinner"
import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle"
import {
Tooltip,
TooltipContent,
TooltipProvider,
TooltipTrigger,
} from "@/components/ui/tooltip"
import {
renderXlsxContextMenu,
renderXlsxScroller,
WorkbookSheetTabs,
WorkbookTableHeaderMenu,
XLSX_CONTEXT_MENU_CLASS_NAME,
xlsxContextMenuStyle,
} from "@/components/extend/xlsx-viewer"
import { IconPlaceholder } from "@/components/icon-placeholder"
function BorderAll01Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="Grid2x2"
tabler="IconBorderAll"
hugeicons="BorderAll01Icon"
phosphor="GridFourIcon"
remixicon="RiGridLine"
{...props}
/>
)
}
function BorderBottom01Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="PanelBottom"
tabler="IconBorderBottom"
hugeicons="BorderBottom01Icon"
phosphor="SquareHalfBottomIcon"
remixicon="RiLayoutBottomLine"
{...props}
/>
)
}
function BorderLeft01Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="PanelLeft"
tabler="IconBorderLeft"
hugeicons="BorderLeft01Icon"
phosphor="SquareHalfIcon"
remixicon="RiLayoutLeftLine"
{...props}
/>
)
}
function BorderNone01Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="SquareDashed"
tabler="IconBorderNone"
hugeicons="BorderNone01Icon"
phosphor="SelectionIcon"
remixicon="RiCheckboxBlankLine"
{...props}
/>
)
}
function BorderRight01Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="PanelRight"
tabler="IconBorderRight"
hugeicons="BorderRight01Icon"
phosphor="SquareHalfIcon"
remixicon="RiLayoutRightLine"
{...props}
/>
)
}
function BorderTop01Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="PanelTop"
tabler="IconBorderTop"
hugeicons="BorderTop01Icon"
phosphor="AlignTopSimpleIcon"
remixicon="RiLayoutTopLine"
{...props}
/>
)
}
function Calendar03Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="Calendar"
tabler="IconCalendar"
hugeicons="Calendar03Icon"
phosphor="CalendarIcon"
remixicon="RiCalendarLine"
{...props}
/>
)
}
function DollarCircleGlyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="CircleDollarSign"
tabler="IconCurrencyDollar"
hugeicons="DollarCircleIcon"
phosphor="CurrencyCircleDollarIcon"
remixicon="RiMoneyDollarCircleLine"
{...props}
/>
)
}
function Moon02Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="Moon"
tabler="IconMoon"
hugeicons="Moon02Icon"
phosphor="MoonIcon"
remixicon="RiMoonLine"
{...props}
/>
)
}
function PaintBucketGlyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="PaintBucket"
tabler="IconPaint"
hugeicons="PaintBucketIcon"
phosphor="PaintBucketIcon"
remixicon="RiPaintFill"
{...props}
/>
)
}
function PercentGlyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="Percent"
tabler="IconPercentage"
hugeicons="PercentIcon"
phosphor="PercentIcon"
remixicon="RiPercentLine"
{...props}
/>
)
}
function Sun03Glyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="Sun"
tabler="IconSun"
hugeicons="Sun03Icon"
phosphor="SunIcon"
remixicon="RiSunLine"
{...props}
/>
)
}
function TextColorGlyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="Baseline"
tabler="IconTextColor"
hugeicons="TextColorIcon"
phosphor="TextAaIcon"
remixicon="RiFontColor"
{...props}
/>
)
}
function TextNumberSignGlyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="Hash"
tabler="IconHash"
hugeicons="TextNumberSignIcon"
phosphor="HashIcon"
remixicon="RiHashtag"
{...props}
/>
)
}
function TextWrapGlyph(props: RegistryIconProps) {
return (
<IconPlaceholder
lucide="WrapText"
tabler="IconTextWrap"
hugeicons="TextWrapIcon"
phosphor="ArrowElbowDownLeftIcon"
remixicon="RiTextWrap"
{...props}
/>
)
}
const XLSX_LOADING_INDICATOR_DELAY_MS = 300
const XLSX_EDITOR_READ_ONLY_THRESHOLD_BYTES = 5 * 1024 * 1024
const XLSX_DROPDOWN_Z_INDEX_CLASS = "z-40"
const ZOOM_OPTIONS = [50, 75, 100, 125, 150, 200, 400] as const
const DEFAULT_FONT_FAMILY = "Arial"
const FONT_FAMILIES = [
"Arial",
"Times New Roman",
"Georgia",
"Helvetica",
"Courier New",
] as const
const FONT_SIZE_OPTIONS = [
8, 9, 10, 11, 12, 14, 16, 18, 20, 24, 28, 32, 36, 48,
] as const
const DEFAULT_TEXT_COLOR = "#111827"
const DEFAULT_FILL_COLOR = "#fde68a"
const DEFAULT_BORDER_COLOR = "#111827"
const XLSX_EDITOR_SELECT_CHROME_CLASS =
"shadow-none before:shadow-none not-data-disabled:not-focus-visible:not-aria-invalid:not-data-pressed:before:shadow-none dark:not-data-disabled:not-focus-visible:not-aria-invalid:not-data-pressed:before:shadow-none"
const XLSX_EDITOR_FORMULA_INPUT_CHROME_CLASS =
"has-disabled:opacity-100 dark:has-disabled:before:shadow-[0_-1px_--theme(--color-white/6%)]"
type UploadedWorkbook = {
buffer: ArrayBuffer
fileName: string
identity: string
}
type NumberFormatOption = {
formatString?: string
formatType: NonNullable<XlsxCellStyleInput["numberFormat"]>["formatType"]
icon: React.ComponentType<RegistryIconProps>
id?: number
label: string
value: string
}
type BorderOption = {
action: XlsxBorderAction
icon: React.ComponentType<RegistryIconProps>
label: string
}
type XlsxResolvedCellStyle = XlsxSheetData["styleById"][number]
type XlsxResolvedStyleGroup = Record<string, unknown>
type HorizontalAlignment = NonNullable<XlsxCellAlignmentInput["horizontal"]>
type VerticalAlignment = NonNullable<XlsxCellAlignmentInput["vertical"]>
type HorizontalAlignmentToggleValue = Extract<
HorizontalAlignment,
"left" | "center" | "right"
>
type VerticalAlignmentToggleValue = Extract<
VerticalAlignment,
"top" | "center" | "bottom"
>
type XlsxFontToggleValue = "bold" | "italic" | "underline" | "strikethrough"
type XlsxMergeRegion = XlsxCellRange
type XlsxBorderEdgeKey = "bottom" | "left" | "top" | "right"
type XlsxBorderAction = "all" | "outside" | "none" | XlsxBorderEdgeKey
type XlsxWorksheetWithMergeRegions = {
mergedRegions?: unknown[]
unmergeCells?: (range: string) => boolean
}
const NUMBER_FORMAT_OPTIONS: NumberFormatOption[] = [
{
formatType: "general",
icon: TextNumberSignGlyph,
label: "General",
value: "General",
},
{
formatString: "0.00",
formatType: "custom",
icon: TextNumberSignGlyph,
label: "Number",
value: "Number",
},
{
formatString: "$#,##0.00",
formatType: "custom",
icon: DollarCircleGlyph,
label: "Currency",
value: "Currency",
},
{
formatString: "0.00%",
formatType: "custom",
icon: PercentGlyph,
label: "Percent",
value: "Percent",
},
{
formatString: "m/d/yyyy",
formatType: "custom",
icon: Calendar03Glyph,
label: "Date",
value: "Date",
},
]
const GENERAL_NUMBER_FORMAT_VALUE = "General"
const BUILTIN_NUMBER_FORMAT_VALUE_PREFIX = "builtin:"
function formatWorkbookName(fileName: string | undefined, url: string) {
if (fileName?.trim()) return fileName
const pathname = url.split("?")[0] ?? ""
const rawName = pathname.split("/").pop() ?? "workbook.xlsx"
try {
return decodeURIComponent(rawName)
} catch {
return rawName
}
}
function useDelayedLoadingIndicator(isLoading: boolean, delayMs: number) {
const [showSpinner, setShowSpinner] = React.useState(false)
const [previousIsLoading, setPreviousIsLoading] = React.useState(isLoading)
if (previousIsLoading !== isLoading) {
setPreviousIsLoading(isLoading)
setShowSpinner(false)
}
React.useEffect(() => {
if (!isLoading) return
const timeoutId = window.setTimeout(() => {
setShowSpinner(true)
}, delayMs)
return () => window.clearTimeout(timeoutId)
}, [delayMs, isLoading])
return isLoading && showSpinner
}
function normalizeHexColor(value: string, fallback = DEFAULT_TEXT_COLOR) {
const trimmed = value.trim()
const threeDigit = /^#?([0-9a-f]{3})$/i.exec(trimmed)
if (threeDigit?.[1]) {
const [red, green, blue] = threeDigit[1].split("")
return `#${red}${red}${green}${green}${blue}${blue}`.toLowerCase()
}
const sixDigit = /^#?([0-9a-f]{6})$/i.exec(trimmed)
if (sixDigit?.[1]) {
return `#${sixDigit[1].toLowerCase()}`
}
return fallback
}
function toXlsxRgbColor(value: string) {
return {
colorType: "rgb" as const,
hex: normalizeHexColor(value).slice(1).toUpperCase(),
}
}
function asResolvedStyleGroup(
value: unknown
): XlsxResolvedStyleGroup | undefined {
return value && typeof value === "object" && !Array.isArray(value)
? (value as XlsxResolvedStyleGroup)
: undefined
}
function mergeResolvedCellStyle(
base: XlsxResolvedCellStyle | null | undefined,
overlay: XlsxResolvedCellStyle | null | undefined
): XlsxResolvedCellStyle | null {
if (!base && !overlay) return null
const nextStyle = { ...(base ?? {}), ...(overlay ?? {}) }
const baseFont = asResolvedStyleGroup(base?.font)
const overlayFont = asResolvedStyleGroup(overlay?.font)
if (baseFont || overlayFont) {
nextStyle.font = overlayFont ?? baseFont
}
return nextStyle
}
function resolveInheritedCellStyle(
sheet: XlsxSheetData | null,
row: number,
col: number
): XlsxResolvedCellStyle | null {
if (!sheet) return null
const colStyleId = sheet.colStyleIds[col]
const rowStyleId = sheet.rowStyleIds[row]
const colStyle =
colStyleId !== undefined ? sheet.styleById[colStyleId] : undefined
const rowStyle =
rowStyleId !== undefined ? sheet.styleById[rowStyleId] : undefined
return mergeResolvedCellStyle(colStyle, rowStyle)
}
function getFontToggleValuesFromStyle(
style: XlsxResolvedCellStyle | null
): XlsxFontToggleValue[] {
const font = asResolvedStyleGroup(style?.font)
const values: XlsxFontToggleValue[] = []
if (font?.bold === true) values.push("bold")
if (font?.italic === true) values.push("italic")
if (font?.underline && font.underline !== "none") values.push("underline")
if (font?.strikethrough === true) values.push("strikethrough")
return values
}
function getFontFamilyValue(style: XlsxResolvedCellStyle | null) {
const font = asResolvedStyleGroup(style?.font)
const fontName = font?.name
return typeof fontName === "string" && fontName.trim()
? fontName.trim()
: undefined
}
function getHorizontalAlignmentValue(
style: XlsxResolvedCellStyle | null
): HorizontalAlignmentToggleValue[] {
const alignment = asResolvedStyleGroup(style?.alignment)
const horizontal = alignment?.horizontal
return horizontal === "left" ||
horizontal === "center" ||
horizontal === "right"
? [horizontal]
: []
}
function getVerticalAlignmentValue(
style: XlsxResolvedCellStyle | null
): VerticalAlignmentToggleValue[] {
const alignment = asResolvedStyleGroup(style?.alignment)
const vertical = alignment?.vertical
if (vertical === undefined || vertical === null) return ["bottom"]
return vertical === "top" || vertical === "center" || vertical === "bottom"
? [vertical]
: []
}
function getNumberFormatValue(style: XlsxResolvedCellStyle | null) {
const numberFormat = asResolvedStyleGroup(style?.numberFormat)
if (!numberFormat) return GENERAL_NUMBER_FORMAT_VALUE
const formatType = numberFormat.formatType
const formatString =
typeof numberFormat.formatString === "string"
? numberFormat.formatString.trim()
: ""
const id = getNumericValue(numberFormat.id)
if (formatString) {
const matchingOption = NUMBER_FORMAT_OPTIONS.find(
(option) => option.formatString === formatString
)
return matchingOption?.value ?? formatString
}
if (formatType === "builtin" && id !== undefined) {
const matchingOption = NUMBER_FORMAT_OPTIONS.find(
(option) => option.id === id
)
if (matchingOption) return matchingOption.value
return `${BUILTIN_NUMBER_FORMAT_VALUE_PREFIX}${id}`
}
if (formatType === "general") return GENERAL_NUMBER_FORMAT_VALUE
return GENERAL_NUMBER_FORMAT_VALUE
}
function getNumberFormatLabel(value: string) {
if (value === GENERAL_NUMBER_FORMAT_VALUE) return "General"
const matchingOption = NUMBER_FORMAT_OPTIONS.find(
(option) => option.value === value
)
if (matchingOption) return matchingOption.label
if (value.startsWith(BUILTIN_NUMBER_FORMAT_VALUE_PREFIX)) {
return `Builtin ${value.slice(BUILTIN_NUMBER_FORMAT_VALUE_PREFIX.length)}`
}
return value
}
function getNumberFormatIcon(value: string) {
return (
NUMBER_FORMAT_OPTIONS.find((option) => option.value === value)?.icon ??
TextNumberSignGlyph
)
}
function createNumberFormatStyle(value: string): XlsxCellStyleInput {
const matchingOption = NUMBER_FORMAT_OPTIONS.find(
(option) => option.value === value
)
if (matchingOption) {
return {
numberFormat: {
formatString: matchingOption.formatString,
formatType: matchingOption.formatType,
id: matchingOption.id,
},
}
}
if (value.startsWith(BUILTIN_NUMBER_FORMAT_VALUE_PREFIX)) {
const id = Number(value.slice(BUILTIN_NUMBER_FORMAT_VALUE_PREFIX.length))
if (Number.isFinite(id)) {
return {
numberFormat: {
formatType: "builtin",
id: Math.max(0, Math.trunc(id)),
},
}
}
}
return {
numberFormat: {
formatString: value,
formatType: "custom",
},
}
}
function normalizeCellRange(range: XlsxCellRange): XlsxCellRange {
return {
start: {
row: Math.min(range.start.row, range.end.row),
col: Math.min(range.start.col, range.end.col),
},
end: {
row: Math.max(range.start.row, range.end.row),
col: Math.max(range.start.col, range.end.col),
},
}
}
function getNumericValue(value: unknown) {
return typeof value === "number" && Number.isFinite(value)
? Math.max(0, Math.trunc(value))
: undefined
}
function getWorksheetMergeRegions(
worksheet: XlsxWorksheetWithMergeRegions | null
): XlsxMergeRegion[] {
if (!Array.isArray(worksheet?.mergedRegions)) return []
return worksheet.mergedRegions.flatMap((entry) => {
if (!entry || typeof entry !== "object") return []
const region = entry as Record<string, unknown>
const start = asResolvedStyleGroup(region.start)
const end = asResolvedStyleGroup(region.end)
const startRow = getNumericValue(region.startRow ?? start?.row)
const startCol = getNumericValue(region.startCol ?? start?.col)
const endRow = getNumericValue(region.endRow ?? end?.row)
const endCol = getNumericValue(region.endCol ?? end?.col)
if (
startRow === undefined ||
startCol === undefined ||
endRow === undefined ||
endCol === undefined
) {
return []
}
return [
normalizeCellRange({
start: { row: startRow, col: startCol },
end: { row: endRow, col: endCol },
}),
]
})
}
function rangesIntersect(
firstRange: XlsxCellRange,
secondRange: XlsxCellRange
) {
const first = normalizeCellRange(firstRange)
const second = normalizeCellRange(secondRange)
return (
first.start.row <= second.end.row &&
first.end.row >= second.start.row &&
first.start.col <= second.end.col &&
first.end.col >= second.start.col
)
}
function isSingleCellRange(range: XlsxCellRange) {
const normalizedRange = normalizeCellRange(range)
return (
normalizedRange.start.row === normalizedRange.end.row &&
normalizedRange.start.col === normalizedRange.end.col
)
}
function getCellColumnLabel(col: number) {
let label = ""
let value = col
do {
label = String.fromCharCode(65 + (value % 26)) + label
value = Math.floor(value / 26) - 1
} while (value >= 0)
return label
}
function cellAddressToA1(cell: XlsxCellRange["start"]) {
return `${getCellColumnLabel(cell.col)}${cell.row + 1}`
}
function rangeToA1(range: XlsxCellRange) {
const normalizedRange = normalizeCellRange(range)
return `${cellAddressToA1(normalizedRange.start)}:${cellAddressToA1(
normalizedRange.end
)}`
}
function getRangeKey(range: XlsxCellRange) {
const normalizedRange = normalizeCellRange(range)
return `${normalizedRange.start.row}:${normalizedRange.start.col}:${normalizedRange.end.row}:${normalizedRange.end.col}`
}
function createBorderEdge(
color = DEFAULT_BORDER_COLOR
): XlsxCellBorderEdgeInput {
return {
color: toXlsxRgbColor(color),
style: "thin",
}
}
function createBorderPatch(
entries: Partial<Record<XlsxBorderEdgeKey, XlsxCellBorderEdgeInput>>
): XlsxCellStyleInput {
return {
border: entries,
}
}
function createNoBorderPatch(): XlsxCellStyleInput {
return {
border: {
bottom: { style: "none" },
left: { style: "none" },
right: { style: "none" },
top: { style: "none" },
},
}
}
function createBorderOptions(): BorderOption[] {
return [
{
action: "bottom",
icon: BorderBottom01Glyph,
label: "Bottom border",
},
{
action: "left",
icon: BorderLeft01Glyph,
label: "Left border",
},
{
action: "top",
icon: BorderTop01Glyph,
label: "Top border",
},
{
action: "right",
icon: BorderRight01Glyph,
label: "Right border",
},
{
action: "all",
icon: BorderAll01Glyph,
label: "All borders",
},
{
action: "outside",
icon: BorderAll01Glyph,
label: "Outside border",
},
{
action: "none",
icon: BorderNone01Glyph,
label: "No border",
},
]
}
function getBorderEdgeRange(
range: XlsxCellRange,
edgeKey: XlsxBorderEdgeKey
): XlsxCellRange {
const normalizedRange = normalizeCellRange(range)
if (edgeKey === "top") {
return {
start: normalizedRange.start,
end: { row: normalizedRange.start.row, col: normalizedRange.end.col },
}
}
if (edgeKey === "bottom") {
return {
start: { row: normalizedRange.end.row, col: normalizedRange.start.col },
end: normalizedRange.end,
}
}
if (edgeKey === "left") {
return {
start: normalizedRange.start,
end: { row: normalizedRange.end.row, col: normalizedRange.start.col },
}
}
return {
start: { row: normalizedRange.start.row, col: normalizedRange.end.col },
end: normalizedRange.end,
}
}
function ToolbarTooltip({
label,
children,
}: {
label: string
children: React.ReactNode
}) {
return (
<Tooltip>
<TooltipTrigger asChild>
<span className="inline-flex">{children}</span>
</TooltipTrigger>
<TooltipContent side="bottom">{label}</TooltipContent>
</Tooltip>
)
}
function EditorLoadingSurface({
showSpinner = true,
}: {
showSpinner?: boolean
}) {
return (
<div className="grid h-full min-h-52 w-full min-w-full place-items-center bg-transparent">
{showSpinner ? <Spinner className="size-4" /> : null}
</div>
)
}
function ToolbarIconButton({
active,
children,
label,
...props
}: React.ComponentProps<typeof Button> & {
active?: boolean
label: string
}) {
return (
<ToolbarTooltip label={label}>
<Button
type="button"
variant={active ? "secondary" : "ghost"}
size="icon-sm"
aria-label={label}
data-pressed={active ? "" : undefined}
{...props}
>
{children}
</Button>
</ToolbarTooltip>
)
}
function ToolbarSeparator() {
return <Separator orientation="vertical" className="mx-1 h-4 self-center" />
}
function StyleDropdownItem({
children,
icon,
onClick,
}: {
children: React.ReactNode
icon: React.ComponentType<RegistryIconProps>
onClick: () => void
}) {
const IconComponent = icon
return (
<DropdownMenuItem onClick={onClick}>
<IconComponent className="size-4" />
{children}
</DropdownMenuItem>
)
}
function MergeCellsMenu({
canMerge,
canMergeAcross,
canUnmerge,
disabled,
isMerged,
onMergeAcross,
onMergeAndCenter,
onMergeCells,
onUnmergeCells,
}: {
canMerge: boolean
canMergeAcross: boolean
canUnmerge: boolean
disabled: boolean
isMerged: boolean
onMergeAcross: () => void
onMergeAndCenter: () => void
onMergeCells: () => void
onUnmergeCells: () => void
}) {
return (
<DropdownMenu>
<div
className={cn(
"inline-flex shrink-0 overflow-hidden rounded-lg border border-transparent"
)}
>
<ToolbarTooltip
label={isMerged ? "Unmerge cells from the menu" : "Merge & Center"}
>
<Button
type="button"
variant={isMerged ? "secondary" : "ghost"}
size="sm"
aria-label="Merge & Center"
className="h-7 rounded-r-none border-0 px-2.5 before:rounded-r-none"
data-pressed={isMerged ? "" : undefined}
disabled={disabled || !canMerge}
onClick={onMergeAndCenter}
>
<IconPlaceholder
lucide="TableCellsMerge"
tabler="IconArrowMerge"
hugeicons="PathfinderMergeIcon"
phosphor="ArrowsMergeIcon"
remixicon="RiMergeCellsVertical"
className="size-4"
/>
<span className="hidden text-xs font-medium lg:inline">
Merge & Center
</span>
</Button>
</ToolbarTooltip>
<DropdownMenuTrigger asChild>
<Button
type="button"
variant={isMerged ? "secondary" : "ghost"}
size="icon-sm"
aria-label="Merge cells options"
className="h-7 w-6 rounded-l-none border-0 px-0 before:rounded-l-none"
data-pressed={isMerged ? "" : undefined}
disabled={disabled}
>
<IconPlaceholder
lucide="ChevronDown"
tabler="IconChevronDown"
hugeicons="ChevronDownIcon"
phosphor="CaretDownIcon"
remixicon="RiArrowDownSLine"
className="size-3.5 opacity-100"
/>
</Button>
</DropdownMenuTrigger>
</div>
<DropdownMenuContent
align="start"
className={cn("w-56", XLSX_DROPDOWN_Z_INDEX_CLASS)}
>
<DropdownMenuItem disabled={!canMerge} onClick={onMergeAndCenter}>
<IconPlaceholder
lucide="TableCellsMerge"
tabler="IconArrowMerge"
hugeicons="PathfinderMergeIcon"
phosphor="ArrowsMergeIcon"
remixicon="RiMergeCellsVertical"
className="size-4"
/>
Merge & Center
</DropdownMenuItem>
<DropdownMenuItem disabled={!canMergeAcross} onClick={onMergeAcross}>
<IconPlaceholder
lucide="TableRowsSplit"
tabler="IconArrowsSplit"
hugeicons="TableRowsSplitIcon"
phosphor="ArrowsSplitIcon"
remixicon="RiSplitCellsVertical"
className="size-4"
/>
Merge Across
</DropdownMenuItem>
<DropdownMenuItem disabled={!canMerge} onClick={onMergeCells}>
<IconPlaceholder
lucide="Grid3x3"
tabler="IconGrid4x4"
hugeicons="CellsIcon"
phosphor="GridNineIcon"
remixicon="RiMergeCellsHorizontal"
className="size-4"
/>
Merge Cells
</DropdownMenuItem>
<DropdownMenuSeparator />
<DropdownMenuItem disabled={!canUnmerge} onClick={onUnmergeCells}>
<IconPlaceholder
lucide="Grid2x2X"
tabler="IconTableMinus"
hugeicons="Grid2X2XIcon"
phosphor="SelectionSlashIcon"
remixicon="RiSplitCellsHorizontal"
className="size-4"
/>
Unmerge Cells
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
)
}
function NumberFormatSelect({
disabled,
onApplyStyle,
value,
}: {
disabled: boolean
onApplyStyle: (style: XlsxCellStyleInput) => void
value: string
}) {
const hasMatchingOption = NUMBER_FORMAT_OPTIONS.some(
(option) => option.value === value
)
const currentLabel = getNumberFormatLabel(value)
const currentIcon = React.createElement(getNumberFormatIcon(value), {
className: "size-4",
})
return (
<Select
value={value}
onValueChange={(nextValue) => {
if (!nextValue) return
onApplyStyle(createNumberFormatStyle(nextValue))
}}
disabled={disabled}
>
<SelectTrigger
size="sm"
className={cn(
"w-[132px] min-w-[132px]",
XLSX_EDITOR_SELECT_CHROME_CLASS
)}
aria-label="Number format"
>
{currentIcon}
<SelectValue placeholder="General" />
</SelectTrigger>
<SelectContent
align="start"
alignItemWithTrigger={false}
className={XLSX_DROPDOWN_Z_INDEX_CLASS}
>
{NUMBER_FORMAT_OPTIONS.map((option) => (
<SelectItem key={option.value} value={option.value}>
<span className="flex min-w-0 items-center gap-2">
<option.icon className="size-4" />
<span className="truncate">{option.label}</span>
</span>
</SelectItem>
))}
{!hasMatchingOption && value !== GENERAL_NUMBER_FORMAT_VALUE ? (
<SelectItem value={value}>
<span className="flex min-w-0 items-center gap-2">
{currentIcon}
<span className="truncate">{currentLabel}</span>
</span>
</SelectItem>
) : null}
</SelectContent>
</Select>
)
}
function BorderMenu({
borderColor,
disabled,
onApplyBorder,
onBorderColorChange,
}: {
borderColor: string
disabled: boolean
onApplyBorder: (action: XlsxBorderAction) => void
onBorderColorChange: (color: string) => void
}) {
const borderOptions = React.useMemo(() => createBorderOptions(), [])
const edgeBorderOptions = borderOptions.filter(
(option) =>
option.action === "bottom" ||
option.action === "left" ||
option.action === "top" ||
option.action === "right"
)
const groupedBorderOptions = borderOptions.filter(
(option) =>
option.action === "all" ||
option.action === "outside" ||
option.action === "none"
)
return (
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon-sm"
disabled={disabled}
aria-label="Cell borders"
className="relative"
>
<IconPlaceholder
lucide="Grid2x2"
tabler="IconBorderAll"
hugeicons="BorderAll01Icon"
phosphor="GridFourIcon"
remixicon="RiGridLine"
className="size-4"
/>
<span
className="absolute right-1 bottom-1 h-1 w-4 rounded-full border border-background"
style={{ backgroundColor: borderColor }}
/>
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent
align="start"
className={cn("w-48", XLSX_DROPDOWN_Z_INDEX_CLASS)}
>
{edgeBorderOptions.map((option) => (
<StyleDropdownItem
key={option.label}
icon={option.icon}
onClick={() => onApplyBorder(option.action)}
>
{option.label}
</StyleDropdownItem>
))}
<DropdownMenuSeparator />
<DropdownMenuGroup>
{groupedBorderOptions.map((option) => (
<StyleDropdownItem
key={option.label}
icon={option.icon}
onClick={() => onApplyBorder(option.action)}
>
{option.label}
</StyleDropdownItem>
))}
</DropdownMenuGroup>
<DropdownMenuSeparator />
<DropdownMenuSub>
<DropdownMenuSubTrigger>
<IconPlaceholder
lucide="Baseline"
tabler="IconTextColor"
hugeicons="TextColorIcon"
phosphor="TextAaIcon"
remixicon="RiFontColor"
className="size-4 text-muted-foreground"
/>
Border color
<span
className="h-3 w-5 rounded-full border border-border"
style={{ backgroundColor: borderColor }}
/>
</DropdownMenuSubTrigger>
<DropdownMenuSubContent
className={cn("w-auto p-3", XLSX_DROPDOWN_Z_INDEX_CLASS)}
>
<ColorPickerPanel
label="Border color"
color={borderColor}
onChange={(color) =>
onBorderColorChange(normalizeHexColor(color))
}
/>
</DropdownMenuSubContent>
</DropdownMenuSub>
</DropdownMenuContent>
</DropdownMenu>
)
}
function AlignmentMoreMenu({
disabled,
onApplyStyle,
}: {
disabled: boolean
onApplyStyle: (style: XlsxCellStyleInput) => void
}) {
return (
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon-sm"
disabled={disabled}
aria-label="More alignment"
>
<IconPlaceholder
lucide="Ellipsis"
tabler="IconDots"
hugeicons="MoreHorizontalIcon"
phosphor="DotsThreeIcon"
remixicon="RiMoreLine"
className="size-4"
/>
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent
align="start"
className={cn("w-48", XLSX_DROPDOWN_Z_INDEX_CLASS)}
>
<StyleDropdownItem
icon={TextWrapGlyph}
onClick={() => onApplyStyle({ alignment: { wrapText: false } })}
>
Do not wrap
</StyleDropdownItem>
<StyleDropdownItem
icon={TextWrapGlyph}
onClick={() => onApplyStyle({ alignment: { shrinkToFit: true } })}
>
Shrink to fit
</StyleDropdownItem>
<StyleDropdownItem
icon={TextWrapGlyph}
onClick={() => onApplyStyle({ alignment: { shrinkToFit: false } })}
>
Do not shrink
</StyleDropdownItem>
</DropdownMenuContent>
</DropdownMenu>
)
}
function EditorFileActionsMenu({
canExport,
exportXlsx,
onUploadClick,
}: {
canExport: boolean
exportXlsx: () => void
onUploadClick: () => void
}) {
return (
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon-sm"
aria-label="Open workbook actions"
>
<IconPlaceholder
lucide="Ellipsis"
tabler="IconDots"
hugeicons="MoreHorizontalIcon"
phosphor="DotsThreeIcon"
remixicon="RiMoreLine"
className="size-4"
/>
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent
align="end"
className={cn("w-40", XLSX_DROPDOWN_Z_INDEX_CLASS)}
>
<DropdownMenuItem disabled={!canExport} onClick={exportXlsx}>
<IconPlaceholder
lucide="Download"
tabler="IconDownload"
hugeicons="Download01Icon"
phosphor="DownloadSimpleIcon"
remixicon="RiDownload2Line"
className="size-4"
/>
Download
</DropdownMenuItem>
<DropdownMenuItem onClick={onUploadClick}>
<IconPlaceholder
lucide="Upload"
tabler="IconUpload"
hugeicons="Upload01Icon"
phosphor="UploadSimpleIcon"
remixicon="RiUpload2Line"
className="size-4"
/>
Upload
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
)
}
function EditorToolbar({
isDark,
onIsDarkChange,
onUploadClick,
showNightRenderToggle,
workbookIdentity,
}: {
isDark: boolean
onIsDarkChange: (checked: boolean) => void
onUploadClick: () => void
showNightRenderToggle: boolean
workbookIdentity: string
}) {
const {
activeSheet,
activeSheetIndex,
canExport,
exportXlsx,
getActiveWorksheet,
revision,
setActiveSheetIndex,
sheets,
} = useXlsxViewer()
const { activeCell, activeCellAddress, selectRange, selection } =
useXlsxViewerSelection()
const {
addSheet,
canRedo,
canUndo,
mergeSelection,
pasteStructuredClipboardData,
readOnly,
redo,
removeActiveSheet,
selectedFormula,
selectedValue,
setCellStyle,
setCellFormula,
setCellValue,
setRangeStyle,
setSelectedCellStyle,
undo,
unmergeSelection,
} = useXlsxViewerEditing()
const { canZoomIn, canZoomOut, setZoomScale, zoomIn, zoomOut, zoomScale } =
useXlsxViewerZoom()
const [formulaDraft, setFormulaDraft] = React.useState("")
const [formulaFocused, setFormulaFocused] = React.useState(false)
const [fontFamily, setFontFamily] = React.useState(DEFAULT_FONT_FAMILY)
const [fontSize, setFontSize] = React.useState(11)
const [textColor, setTextColor] = React.useState(DEFAULT_TEXT_COLOR)
const [fillColor, setFillColor] = React.useState(DEFAULT_FILL_COLOR)
const [borderColor, setBorderColor] = React.useState(DEFAULT_BORDER_COLOR)
const [appliedMergeRegions, setAppliedMergeRegions] = React.useState<
XlsxMergeRegion[]
>([])
const lastStyleTargetRef = React.useRef<{
range: XlsxCellRange
sheetIndex: number
workbookIdentity: string
} | null>(null)
const formulaEditCellRef = React.useRef<typeof activeCell>(null)
const formulaInitialValueRef = React.useRef("")
const hasWorkbook = sheets.length > 0
const hasSelection = Boolean(selection)
const hasActiveCell = Boolean(activeCell)
const canStyleSelection = (hasSelection || hasActiveCell) && !readOnly
const activeRange = React.useMemo<XlsxCellRange | null>(() => {
if (selection) return normalizeCellRange(selection)
if (!activeCell) return null
return {
start: activeCell,
end: activeCell,
}
}, [activeCell, selection])
React.useEffect(() => {
if (!activeRange) return
lastStyleTargetRef.current = {
range: activeRange,
sheetIndex: activeSheetIndex,
workbookIdentity,
}
}, [activeRange, activeSheetIndex, workbookIdentity])
const worksheetMergeRegions = React.useMemo(() => {
void revision
return getWorksheetMergeRegions(
getActiveWorksheet() as XlsxWorksheetWithMergeRegions | null
)
}, [getActiveWorksheet, revision])
const mergeRegions = React.useMemo(
() => [...worksheetMergeRegions, ...appliedMergeRegions],
[appliedMergeRegions, worksheetMergeRegions]
)
const selectionIntersectsMerge = Boolean(
activeRange &&
mergeRegions.some((mergeRegion) =>
rangesIntersect(activeRange, mergeRegion)
)
)
const pendingMergeRegions = appliedMergeRegions.filter(
(currentRegion) =>
!worksheetMergeRegions.some((worksheetRegion) =>
rangesIntersect(currentRegion, worksheetRegion)
)
)
if (pendingMergeRegions.length !== appliedMergeRegions.length) {
setAppliedMergeRegions(pendingMergeRegions)
}
const [previousSheetIndex, setPreviousSheetIndex] =
React.useState(activeSheetIndex)
if (!Object.is(previousSheetIndex, activeSheetIndex)) {
setPreviousSheetIndex(activeSheetIndex)
setAppliedMergeRegions([])
}
const selectionIsSingleCell = activeRange
? isSingleCellRange(activeRange)
: true
const selectionSpansMultipleColumns = activeRange
? activeRange.start.col !== activeRange.end.col
: false
const canMergeSelectedCells = Boolean(
selection &&
!readOnly &&
!selectionIntersectsMerge &&
!selectionIsSingleCell
)
const canMergeAcross = Boolean(
selection &&
!readOnly &&
!selectionIntersectsMerge &&
selectionSpansMultipleColumns
)
const canUnmergeSelectedCells = Boolean(
selection && !readOnly && selectionIntersectsMerge
)
const currentZoom = Math.round(zoomScale)
const selectedCellInputValue = selectedFormula || selectedValue
const activeCellStyle = React.useMemo(() => {
// Worksheet style objects are mutable; revision invalidates this read after edits.
void revision
if (!activeCell) return null
const worksheet = getActiveWorksheet()
const inheritedStyle = resolveInheritedCellStyle(
activeSheet,
activeCell.row,
activeCell.col
)
const cellStyle = worksheet?.getCellStyleAt(
activeCell.row,
activeCell.col
) as XlsxResolvedCellStyle | null | undefined
return mergeResolvedCellStyle(inheritedStyle, cellStyle)
}, [activeCell, activeSheet, getActiveWorksheet, revision])
const fontToggleValues = React.useMemo(
() => getFontToggleValuesFromStyle(activeCellStyle),
[activeCellStyle]
)
const fontFamilyValue = getFontFamilyValue(activeCellStyle) ?? fontFamily
const horizontalAlignmentValue = React.useMemo(
() => getHorizontalAlignmentValue(activeCellStyle),
[activeCellStyle]
)
const verticalAlignmentValue = React.useMemo(
() => getVerticalAlignmentValue(activeCellStyle),
[activeCellStyle]
)
const numberFormatValue = React.useMemo(
() => getNumberFormatValue(activeCellStyle),
[activeCellStyle]
)
const commitFormula = React.useCallback(() => {
const targetCell = formulaEditCellRef.current ?? activeCell
if (!targetCell) return
if (formulaDraft === formulaInitialValueRef.current) return
if (formulaDraft.trim().startsWith("=")) {
setCellFormula(targetCell, formulaDraft)
} else {
setCellValue(targetCell, formulaDraft)
}
formulaInitialValueRef.current = formulaDraft
}, [activeCell, formulaDraft, setCellFormula, setCellValue])
const applyStyle = React.useCallback(
(style: XlsxCellStyleInput) => {
const applyRangeStyle = (range: XlsxCellRange) => {
const normalizedRange = normalizeCellRange(range)
const targetRanges = [
normalizedRange,
...mergeRegions.filter((mergeRegion) =>
rangesIntersect(normalizedRange, mergeRegion)
),
]
const uniqueTargetRanges = new Map<string, XlsxCellRange>()
targetRanges.forEach((targetRange) => {
const normalizedTargetRange = normalizeCellRange(targetRange)
uniqueTargetRanges.set(
getRangeKey(normalizedTargetRange),
normalizedTargetRange
)
})
uniqueTargetRanges.forEach((targetRange) => {
setRangeStyle(targetRange, style)
})
}
if (selection) {
const normalizedSelection = normalizeCellRange(selection)
if (!isSingleCellRange(normalizedSelection)) {
applyRangeStyle(normalizedSelection)
return true
}
if (activeCell) {
setSelectedCellStyle(style)
return true
}
setCellStyle(normalizedSelection.start, style)
return true
}
if (activeCell) {
setSelectedCellStyle(style)
return true
}
const fallbackTarget = lastStyleTargetRef.current
const targetRange =
fallbackTarget?.sheetIndex === activeSheetIndex &&
fallbackTarget.workbookIdentity === workbookIdentity
? fallbackTarget.range
: null
if (!targetRange) return false
if (isSingleCellRange(targetRange)) {
setCellStyle(normalizeCellRange(targetRange).start, style)
return true
}
applyRangeStyle(targetRange)
return true
},
[
activeCell,
activeSheetIndex,
mergeRegions,
selection,
setCellStyle,
setRangeStyle,
setSelectedCellStyle,
workbookIdentity,
]
)
const applyBorderAction = React.useCallback(
(action: XlsxBorderAction) => {
if (!activeRange) return
const normalizedRange = normalizeCellRange(activeRange)
const edge = createBorderEdge(borderColor)
const allBorderPatch = createBorderPatch({
bottom: edge,
left: edge,
right: edge,
top: edge,
})
if (action === "all") {
setRangeStyle(normalizedRange, allBorderPatch)
return
}
if (action === "none") {
setRangeStyle(normalizedRange, createNoBorderPatch())
return
}
if (action === "outside") {
if (isSingleCellRange(normalizedRange)) {
setCellStyle(normalizedRange.start, allBorderPatch)
return
}
const outsideEdgeKeys: XlsxBorderEdgeKey[] = [
"top",
"bottom",
"left",
"right",
]
outsideEdgeKeys.forEach((edgeKey) => {
setRangeStyle(
getBorderEdgeRange(normalizedRange, edgeKey),
createBorderPatch({ [edgeKey]: edge })
)
})
return
}
setRangeStyle(
getBorderEdgeRange(normalizedRange, action),
createBorderPatch({ [action]: edge })
)
},
[activeRange, borderColor, setCellStyle, setRangeStyle]
)
const applyHorizontalAlignment = React.useCallback(
(horizontal: HorizontalAlignmentToggleValue | undefined) => {
if (!horizontal) return
applyStyle({ alignment: { horizontal } })
},
[applyStyle]
)
const applyVerticalAlignment = React.useCallback(
(vertical: VerticalAlignmentToggleValue | undefined) => {
if (!vertical) return
applyStyle({ alignment: { vertical } })
},
[applyStyle]
)
const mergeSelectedCells = React.useCallback(() => {
if (!canMergeSelectedCells || !selection) return
setAppliedMergeRegions([normalizeCellRange(selection)])
mergeSelection()
}, [canMergeSelectedCells, mergeSelection, selection])
const mergeAcrossSelectedCells = React.useCallback(() => {
if (!activeCell || !canMergeAcross || !selection) return
const normalizedRange = normalizeCellRange(selection)
const worksheet = getActiveWorksheet()
if (!worksheet) return
const formula = worksheet.getFormulaAt(activeCell.row, activeCell.col)
const rawValue = worksheet.getCellAt(activeCell.row, activeCell.col).toJs()
const colSpan = normalizedRange.end.col - normalizedRange.start.col + 1
const rowSpan = normalizedRange.end.row - normalizedRange.start.row + 1
const merges = Array.from({ length: rowSpan }, (_, rowOffset) => ({
colOffset: normalizedRange.start.col - activeCell.col,
colSpan,
rowOffset: normalizedRange.start.row + rowOffset - activeCell.row,
rowSpan: 1,
}))
const mergeRegionsByRow = Array.from({ length: rowSpan }, (_, rowOffset) =>
normalizeCellRange({
start: {
col: normalizedRange.start.col,
row: normalizedRange.start.row + rowOffset,
},
end: {
col: normalizedRange.end.col,
row: normalizedRange.start.row + rowOffset,
},
})
)
const didPaste = pasteStructuredClipboardData(
JSON.stringify({
cells: [
formula
? { colOffset: 0, formula, rowOffset: 0 }
: { colOffset: 0, rowOffset: 0, value: rawValue ?? "" },
],
cols: colSpan,
merges,
rows: rowSpan,
})
)
if (!didPaste) return
setAppliedMergeRegions(mergeRegionsByRow)
selectRange(normalizedRange)
}, [
activeCell,
canMergeAcross,
getActiveWorksheet,
pasteStructuredClipboardData,
selectRange,
selection,
])
const mergeAndCenterSelectedCells = React.useCallback(() => {
if (!canMergeSelectedCells || !selection) return
setAppliedMergeRegions([normalizeCellRange(selection)])
setRangeStyle(selection, { alignment: { horizontal: "center" } })
mergeSelection()
}, [canMergeSelectedCells, mergeSelection, selection, setRangeStyle])
const unmergeSelectedCells = React.useCallback(() => {
if (!canUnmergeSelectedCells || !activeRange) return
const worksheet =
getActiveWorksheet() as XlsxWorksheetWithMergeRegions | null
if (!worksheet?.unmergeCells) return
const normalizedRange = normalizeCellRange(activeRange)
const uniqueMergeRegions = new Map<string, XlsxMergeRegion>()
;[...worksheetMergeRegions, ...appliedMergeRegions].forEach(
(mergeRegion) => {
if (!rangesIntersect(normalizedRange, mergeRegion)) return
uniqueMergeRegions.set(getRangeKey(mergeRegion), mergeRegion)
}
)
let didUnmerge = false
uniqueMergeRegions.forEach((mergeRegion) => {
didUnmerge =
worksheet.unmergeCells?.(rangeToA1(mergeRegion)) || didUnmerge
})
if (!didUnmerge) {
unmergeSelection()
return
}
setAppliedMergeRegions([])
setRangeStyle(normalizedRange, {})
selectRange(normalizedRange)
}, [
activeRange,
appliedMergeRegions,
canUnmergeSelectedCells,
getActiveWorksheet,
selectRange,
setRangeStyle,
unmergeSelection,
worksheetMergeRegions,
])
const applyFontToggleValues = React.useCallback(
(nextValues: XlsxFontToggleValue[]) => {
const previousValues = fontToggleValues
const changedValue =
nextValues.find((value) => !previousValues.includes(value)) ??
previousValues.find((value) => !nextValues.includes(value))
if (!changedValue) return
const isPressed = nextValues.includes(changedValue)
if (changedValue === "bold") {
applyStyle({ font: { bold: isPressed } })
} else if (changedValue === "italic") {
applyStyle({ font: { italic: isPressed } })
} else if (changedValue === "underline") {
applyStyle({ font: { underline: isPressed ? "single" : "none" } })
} else if (changedValue === "strikethrough") {
applyStyle({ font: { strikethrough: isPressed } })
}
},
[applyStyle, fontToggleValues]
)
return (
<div className="border-b bg-background">
<div className="flex min-h-11 items-center justify-between gap-3 border-b px-3">
<div className="min-w-0 flex-1" />
<TooltipProvider>
<div className="flex shrink-0 items-center gap-1">
{showNightRenderToggle ? (
<>
<ToolbarTooltip
label={isDark ? "Use light workbook" : "Use dark workbook"}
>
<Button
type="button"
variant="ghost"
size="icon-sm"
aria-label={
isDark ? "Use light workbook" : "Use dark workbook"
}
onClick={() => onIsDarkChange(!isDark)}
>
{isDark ? (
<Sun03Glyph className="size-4" />
) : (
<Moon02Glyph className="size-4" />
)}
</Button>
</ToolbarTooltip>
<Separator
orientation="vertical"
className="mx-1 h-4 self-center"
/>
</>
) : null}
<EditorFileActionsMenu
canExport={canExport}
exportXlsx={exportXlsx}
onUploadClick={onUploadClick}
/>
</div>
</TooltipProvider>
</div>
<TooltipProvider>
<div className="flex min-h-12 flex-wrap items-center gap-2 border-b bg-background px-3 py-2">
<div className="flex shrink-0 items-center gap-1">
<ToolbarTooltip label="Undo">
<Button
type="button"
variant="ghost"
size="icon-sm"
aria-label="Undo"
disabled={!canUndo || readOnly}
onClick={undo}
>
<IconPlaceholder
lucide="Undo2"
tabler="IconArrowBackUp"
hugeicons="Undo02Icon"
phosphor="ArrowUUpLeftIcon"
remixicon="RiArrowGoBackLine"
className="size-4"
/>
</Button>
</ToolbarTooltip>
<ToolbarTooltip label="Redo">
<Button
type="button"
variant="ghost"
size="icon-sm"
aria-label="Redo"
disabled={!canRedo || readOnly}
onClick={redo}
>
<IconPlaceholder
lucide="Redo2"
tabler="IconArrowForwardUp"
hugeicons="Redo02Icon"
phosphor="ArrowUUpRightIcon"
remixicon="RiArrowGoForwardLine"
className="size-4"
/>
</Button>
</ToolbarTooltip>
</div>
<ToolbarSeparator />
<div className="flex shrink-0 items-center gap-1">
<Select
value={fontFamilyValue}
onValueChange={(value) => {
if (!value) return
if (applyStyle({ font: { name: value } })) {
setFontFamily(value)
}
}}
disabled={!canStyleSelection}
modal={false}
>
<SelectTrigger
size="sm"
className={cn(
"w-[132px] min-w-[132px]",
XLSX_EDITOR_SELECT_CHROME_CLASS
)}
aria-label="Font family"
>
<SelectValue placeholder="Font">{fontFamilyValue}</SelectValue>
</SelectTrigger>
<SelectContent
align="start"
alignItemWithTrigger={false}
className={XLSX_DROPDOWN_Z_INDEX_CLASS}
>
{FONT_FAMILIES.map((option) => (
<SelectItem key={option} value={option}>
<span style={{ fontFamily: option }}>{option}</span>
</SelectItem>
))}
</SelectContent>
</Select>
<Select
value={String(fontSize)}
onValueChange={(value) => {
const nextFontSize = Number(value)
if (!Number.isFinite(nextFontSize)) return
setFontSize(nextFontSize)
applyStyle({ font: { size: nextFontSize } })
}}
disabled={!canStyleSelection}
modal={false}
>
<SelectTrigger
size="sm"
className={cn(
"w-[78px] min-w-[78px]",
XLSX_EDITOR_SELECT_CHROME_CLASS
)}
aria-label="Font size"
>
<SelectValue placeholder="Size" />
</SelectTrigger>
<SelectContent
align="start"
alignItemWithTrigger={false}
className={XLSX_DROPDOWN_Z_INDEX_CLASS}
>
{FONT_SIZE_OPTIONS.map((size) => (
<SelectItem key={size} value={String(size)}>
{size} pt
</SelectItem>
))}
</SelectContent>
</Select>
</div>
<ToolbarSeparator />
<ToggleGroup
className="shrink-0"
disabled={!canStyleSelection}
multiple
spacing="default"
value={fontToggleValues}
onValueChange={(value) =>
applyFontToggleValues(value as XlsxFontToggleValue[])
}
>
<ToolbarTooltip label="Bold">
<ToggleGroupItem aria-label="Bold" size="sm" value="bold">
<IconPlaceholder
lucide="Bold"
tabler="IconBold"
hugeicons="TextBoldIcon"
phosphor="TextBIcon"
remixicon="RiBold"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
<ToolbarTooltip label="Italic">
<ToggleGroupItem aria-label="Italic" size="sm" value="italic">
<IconPlaceholder
lucide="Italic"
tabler="IconItalic"
hugeicons="TextItalicIcon"
phosphor="TextItalicIcon"
remixicon="RiItalic"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
<ToolbarTooltip label="Underline">
<ToggleGroupItem
aria-label="Underline"
size="sm"
value="underline"
>
<IconPlaceholder
lucide="Underline"
tabler="IconUnderline"
hugeicons="TextUnderlineIcon"
phosphor="TextUnderlineIcon"
remixicon="RiUnderline"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
<ToolbarTooltip label="Strikethrough">
<ToggleGroupItem
aria-label="Strikethrough"
size="sm"
value="strikethrough"
>
<IconPlaceholder
lucide="Strikethrough"
tabler="IconStrikethrough"
hugeicons="TextStrikethroughIcon"
phosphor="TextStrikethroughIcon"
remixicon="RiStrikethrough"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
</ToggleGroup>
<ToolbarSeparator />
<div className="flex shrink-0 items-center gap-1">
<ColorPicker
label="Text color"
icon={TextColorGlyph}
color={textColor}
disabled={!canStyleSelection}
onChange={(color) => {
const nextColor = normalizeHexColor(color)
setTextColor(nextColor)
applyStyle({ font: { color: toXlsxRgbColor(nextColor) } })
}}
/>
<ColorPicker
label="Fill color"
icon={PaintBucketGlyph}
color={fillColor}
disabled={!canStyleSelection}
onChange={(color) => {
const nextColor = normalizeHexColor(color, DEFAULT_FILL_COLOR)
setFillColor(nextColor)
applyStyle({
fill: {
color: toXlsxRgbColor(nextColor),
fillType: "solid",
},
})
}}
/>
<ToolbarIconButton
label="No fill"
disabled={!canStyleSelection}
onClick={() => applyStyle({ fill: { fillType: "none" } })}
>
<IconPlaceholder
lucide="DropletOff"
tabler="IconDropletOff"
hugeicons="DropletOffIcon"
phosphor="DropSlashIcon"
remixicon="RiDropLine"
className="size-4"
/>
</ToolbarIconButton>
</div>
<ToolbarSeparator />
<div className="flex shrink-0 items-center gap-1">
<ToggleGroup
className="shrink-0"
disabled={!canStyleSelection}
spacing="default"
value={horizontalAlignmentValue}
>
<ToolbarTooltip label="Align left">
<ToggleGroupItem
aria-label="Align left"
size="sm"
value="left"
onClick={() => applyHorizontalAlignment("left")}
>
<IconPlaceholder
lucide="AlignLeft"
tabler="IconAlignLeft"
hugeicons="TextAlignLeft01Icon"
phosphor="TextAlignLeftIcon"
remixicon="RiAlignLeft"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
<ToolbarTooltip label="Align center">
<ToggleGroupItem
aria-label="Align center"
size="sm"
value="center"
onClick={() => applyHorizontalAlignment("center")}
>
<IconPlaceholder
lucide="AlignCenter"
tabler="IconAlignCenter"
hugeicons="TextAlignCenterIcon"
phosphor="TextAlignCenterIcon"
remixicon="RiAlignCenter"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
<ToolbarTooltip label="Align right">
<ToggleGroupItem
aria-label="Align right"
size="sm"
value="right"
onClick={() => applyHorizontalAlignment("right")}
>
<IconPlaceholder
lucide="AlignRight"
tabler="IconAlignRight"
hugeicons="TextAlignRight01Icon"
phosphor="TextAlignRightIcon"
remixicon="RiAlignRight"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
</ToggleGroup>
<ToggleGroup
className="shrink-0"
disabled={!canStyleSelection}
spacing="default"
value={verticalAlignmentValue}
>
<ToolbarTooltip label="Align top">
<ToggleGroupItem
aria-label="Align top"
size="sm"
value="top"
onClick={() => applyVerticalAlignment("top")}
>
<IconPlaceholder
lucide="AlignVerticalJustifyStart"
tabler="IconAlignBoxTopCenter"
hugeicons="AlignBoxTopCenterIcon"
phosphor="AlignTopIcon"
remixicon="RiAlignTop"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
<ToolbarTooltip label="Align middle">
<ToggleGroupItem
aria-label="Align middle"
size="sm"
value="center"
onClick={() => applyVerticalAlignment("center")}
>
<IconPlaceholder
lucide="AlignVerticalJustifyCenter"
tabler="IconAlignBoxCenterMiddle"
hugeicons="AlignBoxMiddleCenterIcon"
phosphor="AlignCenterVerticalIcon"
remixicon="RiAlignVertically"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
<ToolbarTooltip label="Align bottom">
<ToggleGroupItem
aria-label="Align bottom"
size="sm"
value="bottom"
onClick={() => applyVerticalAlignment("bottom")}
>
<IconPlaceholder
lucide="AlignVerticalJustifyEnd"
tabler="IconAlignBoxBottomCenter"
hugeicons="AlignBoxBottomCenterIcon"
phosphor="AlignBottomIcon"
remixicon="RiAlignBottom"
className="size-4"
/>
</ToggleGroupItem>
</ToolbarTooltip>
</ToggleGroup>
<ToolbarIconButton
label="Wrap text"
disabled={!canStyleSelection}
onClick={() => applyStyle({ alignment: { wrapText: true } })}
>
<IconPlaceholder
lucide="WrapText"
tabler="IconTextWrap"
hugeicons="TextWrapIcon"
phosphor="ArrowElbowDownLeftIcon"
remixicon="RiTextWrap"
className="size-4"
/>
</ToolbarIconButton>
<AlignmentMoreMenu
disabled={!canStyleSelection}
onApplyStyle={applyStyle}
/>
</div>
<ToolbarSeparator />
<div className="flex shrink-0 items-center gap-1">
<NumberFormatSelect
disabled={!canStyleSelection}
onApplyStyle={applyStyle}
value={numberFormatValue}
/>
<BorderMenu
borderColor={borderColor}
disabled={!canStyleSelection}
onApplyBorder={applyBorderAction}
onBorderColorChange={setBorderColor}
/>
</div>
<ToolbarSeparator />
<div className="flex shrink-0 items-center gap-1">
<MergeCellsMenu
canMerge={canMergeSelectedCells}
canMergeAcross={canMergeAcross}
canUnmerge={canUnmergeSelectedCells}
disabled={!hasSelection || readOnly}
isMerged={selectionIntersectsMerge}
onMergeAcross={mergeAcrossSelectedCells}
onMergeAndCenter={mergeAndCenterSelectedCells}
onMergeCells={mergeSelectedCells}
onUnmergeCells={unmergeSelectedCells}
/>
</div>
<ToolbarSeparator />
<div className="flex shrink-0 items-center gap-1">
<ToolbarTooltip label="Add sheet">
<Button
type="button"
variant="ghost"
size="icon-sm"
aria-label="Add sheet"
disabled={!hasWorkbook || readOnly}
onClick={() => addSheet()}
>
<IconPlaceholder
lucide="Plus"
tabler="IconPlus"
hugeicons="Add01Icon"
phosphor="PlusIcon"
remixicon="RiAddLine"
className="size-4"
/>
</Button>
</ToolbarTooltip>
<ToolbarTooltip label="Remove active sheet">
<Button
type="button"
variant="ghost"
size="icon-sm"
aria-label="Remove active sheet"
disabled={sheets.length <= 1 || readOnly}
onClick={removeActiveSheet}
>
<IconPlaceholder
lucide="Trash2Icon"
tabler="IconTrash"
hugeicons="Delete02Icon"
phosphor="TrashIcon"
remixicon="RiDeleteBinLine"
className="size-4"
/>
</Button>
</ToolbarTooltip>
<Select
value={String(activeSheetIndex)}
onValueChange={(value) => setActiveSheetIndex(Number(value))}
disabled={!hasWorkbook}
>
<SelectTrigger
size="sm"
className={cn(
"w-[150px] min-w-[150px]",
XLSX_EDITOR_SELECT_CHROME_CLASS
)}
aria-label="Active sheet"
>
<SelectValue>{activeSheet?.name ?? "Sheet"}</SelectValue>
</SelectTrigger>
<SelectContent
align="start"
className={XLSX_DROPDOWN_Z_INDEX_CLASS}
>
{sheets.map((sheet, index) => (
<SelectItem
key={`${sheet.name}-${index}`}
value={String(index)}
>
{sheet.name}
</SelectItem>
))}
</SelectContent>
</Select>
</div>
<ToolbarSeparator />
<div className="flex flex-none items-center gap-1">
<ToolbarTooltip label="Zoom out">
<Button
type="button"
variant="ghost"
size="icon-sm"
disabled={!hasWorkbook || !canZoomOut}
aria-label="Zoom out"
onClick={zoomOut}
>
<IconPlaceholder
lucide="CircleMinus"
tabler="IconCircleMinus"
hugeicons="MinusSignCircleIcon"
phosphor="MinusCircleIcon"
remixicon="RiIndeterminateCircleLine"
className="size-4"
/>
</Button>
</ToolbarTooltip>
<Select
value={currentZoom.toString()}
onValueChange={(value) => setZoomScale(Number(value))}
disabled={!hasWorkbook}
modal={false}
>
<SelectTrigger
size="sm"
className={cn(
"w-[84px] min-w-[84px]",
XLSX_EDITOR_SELECT_CHROME_CLASS
)}
aria-label="Zoom level"
>
<SelectValue>{currentZoom}%</SelectValue>
</SelectTrigger>
<SelectContent
align="end"
alignItemWithTrigger={false}
className={XLSX_DROPDOWN_Z_INDEX_CLASS}
>
{ZOOM_OPTIONS.map((value) => (
<SelectItem key={value} value={value.toString()}>
{value}%
</SelectItem>
))}
</SelectContent>
</Select>
<ToolbarTooltip label="Zoom in">
<Button
type="button"
variant="ghost"
size="icon-sm"
disabled={!hasWorkbook || !canZoomIn}
aria-label="Zoom in"
onClick={zoomIn}
>
<IconPlaceholder
lucide="CirclePlusIcon"
tabler="IconCirclePlusFilled"
hugeicons="PlusSignCircleIcon"
phosphor="PlusCircleIcon"
remixicon="RiAddCircleFill"
className="size-4"
/>
</Button>
</ToolbarTooltip>
</div>
</div>
<div className="border-t bg-background px-2 py-1">
<Group className="w-full">
<Input
className={cn(
"h-8 w-[92px] shrink-0 font-mono text-xs",
XLSX_EDITOR_FORMULA_INPUT_CHROME_CLASS
)}
readOnly
value={activeCellAddress ?? ""}
/>
<GroupSeparator />
<GroupText className="h-8 w-9 shrink-0 justify-center px-0 text-[11px] font-semibold italic">
fx
</GroupText>
<GroupSeparator />
<Input
className={cn(
"h-8 flex-1",
XLSX_EDITOR_FORMULA_INPUT_CHROME_CLASS
)}
disabled={!hasActiveCell || readOnly}
value={formulaFocused ? formulaDraft : selectedCellInputValue}
onBlur={() => {
commitFormula()
setFormulaFocused(false)
}}
onChange={(event) => setFormulaDraft(event.target.value)}
onFocus={() => {
formulaEditCellRef.current = activeCell
formulaInitialValueRef.current = selectedCellInputValue
setFormulaDraft(selectedCellInputValue)
setFormulaFocused(true)
}}
onKeyDown={(event) => {
if (event.key === "Enter") {
event.preventDefault()
commitFormula()
setFormulaFocused(false)
}
}}
placeholder="Select a cell, then enter a value or formula"
/>
</Group>
</div>
</TooltipProvider>
</div>
)
}
export function XlsxEditorSurface({
className,
isDark,
onIsDarkChange,
onUploadClick,
renderTableHeaderMenu,
showNightRenderToggle,
workbookIdentity,
}: {
className?: string
isDark: boolean
onIsDarkChange: (checked: boolean) => void
onUploadClick: () => void
renderTableHeaderMenu: (
props: XlsxTableHeaderMenuRenderProps
) => React.ReactNode
showNightRenderToggle: boolean
workbookIdentity: string
}) {
const { error } = useXlsxViewer()
return (
<div
className={cn(
"flex h-[640px] min-h-0 flex-col overflow-hidden bg-background",
className
)}
>
<EditorToolbar
isDark={isDark}
onIsDarkChange={onIsDarkChange}
onUploadClick={onUploadClick}
showNightRenderToggle={showNightRenderToggle}
workbookIdentity={workbookIdentity}
/>
<div className="flex min-h-0 flex-1 flex-col">
<div className="min-h-0 flex-1 bg-muted/20">
<XlsxViewer
allowResizeInReadOnly
className="h-full min-h-0 min-w-0"
height="100%"
isDark={isDark}
readOnly={false}
rounded={false}
showDefaultToolbar={false}
showImages
fileTooLargeState={
<div className="grid h-full w-full min-w-full place-items-center p-6">
<div className="max-w-sm rounded-lg border bg-background p-4 text-sm">
<p className="font-medium">File too large for editing</p>
<p className="mt-1 text-muted-foreground">
This workbook exceeds the editor limit. Download it or open
a smaller file to make changes.
</p>
</div>
</div>
}
loadingState={<EditorLoadingSurface />}
renderScroller={renderXlsxScroller}
errorState={
<div className="grid h-full w-full min-w-full place-items-center p-6 text-sm text-destructive">
{error?.message ?? "Unable to edit workbook."}
</div>
}
contextMenuClassName={XLSX_CONTEXT_MENU_CLASS_NAME}
contextMenuStyle={xlsxContextMenuStyle}
renderContextMenu={renderXlsxContextMenu}
renderTableHeaderMenu={renderTableHeaderMenu}
/>
</div>
<WorkbookSheetTabs workbookIdentity={workbookIdentity} />
</div>
</div>
)
}
export function XlsxEditorPreview({
className,
fileName,
isDark,
onIsDarkChange,
src,
}: {
className?: string
fileName?: string
isDark: boolean
onIsDarkChange: (isDark: boolean) => void
src?: string
}) {
return (
<XlsxEditorContent
key={src}
className={className}
effectiveIsDark={isDark}
fileName={fileName}
setNightRenderEnabled={onIsDarkChange}
shouldRenderNightMode
url={src}
/>
)
}
function XlsxEditorContent({
className,
effectiveIsDark,
fileName,
setNightRenderEnabled,
shouldRenderNightMode,
url,
}: {
className?: string
effectiveIsDark: boolean
fileName?: string
setNightRenderEnabled: (checked: boolean) => void
shouldRenderNightMode: boolean
url?: string
}) {
const fileInputRef = React.useRef<HTMLInputElement>(null)
const [uploadedWorkbook, setUploadedWorkbook] =
React.useState<UploadedWorkbook | null>(null)
const [workbookBuffer, setWorkbookBuffer] =
React.useState<ArrayBuffer | null>(null)
const [loadError, setLoadError] = React.useState<string>()
const sourceFileName = React.useMemo(
() =>
url ? formatWorkbookName(fileName, url) : (fileName ?? "workbook.xlsx"),
[fileName, url]
)
const displayFileName = uploadedWorkbook?.fileName ?? sourceFileName
const workbookIdentity =
uploadedWorkbook?.identity ?? `${url ?? "empty"}::${displayFileName}`
const shouldShowLoadingSpinner = useDelayedLoadingIndicator(
!workbookBuffer && !loadError && !uploadedWorkbook,
XLSX_LOADING_INDICATOR_DELAY_MS
)
React.useEffect(() => {
let isCurrent = true
async function loadWorkbook(): Promise<void> {
if (!url) return
try {
const response = await fetch(url)
if (!response.ok) {
throw new Error(`Failed to fetch XLSX (${response.status})`)
}
const nextWorkbookBuffer = await response.arrayBuffer()
if (!isCurrent) return
setWorkbookBuffer(nextWorkbookBuffer)
} catch (error) {
if (!isCurrent) return
setLoadError(
error instanceof Error ? error.message : "Unknown XLSX load error"
)
}
}
void loadWorkbook()
return () => {
isCurrent = false
}
}, [url])
async function handleUpload(event: React.ChangeEvent<HTMLInputElement>) {
const file = event.target.files?.[0]
event.target.value = ""
if (!file) return
const buffer = await file.arrayBuffer()
setWorkbookBuffer(null)
setLoadError(undefined)
setUploadedWorkbook({
buffer,
fileName: file.name,
identity: `${file.name}-${file.size}-${file.lastModified}`,
})
}
const activeBuffer = uploadedWorkbook?.buffer ?? workbookBuffer
if (!url && !uploadedWorkbook) {
return (
<div
className={cn(
"flex h-[640px] min-h-0 flex-col overflow-hidden bg-background",
className
)}
>
<input
ref={fileInputRef}
type="file"
accept=".xlsx,.xls,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,application/vnd.ms-excel"
className="hidden"
onChange={handleUpload}
/>
<div className="grid min-h-0 flex-1 place-items-center bg-muted/30 p-4">
<div className="max-w-md rounded-lg border bg-background p-4 text-center text-sm shadow-xs">
<p className="font-medium">Upload a workbook to edit</p>
<p className="mt-1 text-muted-foreground">
Pass an XLSX URL with the <code>src</code> prop or upload a local
file.
</p>
<Button
type="button"
variant="outline"
size="sm"
className="mt-4"
onClick={() => fileInputRef.current?.click()}
>
<IconPlaceholder
lucide="Upload"
tabler="IconUpload"
hugeicons="Upload01Icon"
phosphor="UploadSimpleIcon"
remixicon="RiUpload2Line"
className="size-4"
/>
Upload XLSX
</Button>
</div>
</div>
</div>
)
}
if (loadError && !activeBuffer) {
return (
<div
className={cn(
"flex h-[640px] min-h-0 flex-col overflow-hidden bg-background",
className
)}
>
<input
ref={fileInputRef}
type="file"
accept=".xlsx,.xls,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,application/vnd.ms-excel"
className="hidden"
onChange={handleUpload}
/>
<div className="grid min-h-0 flex-1 place-items-center bg-muted/30 p-4">
<div className="max-w-md rounded-lg border bg-background p-4 text-sm">
<p className="font-medium">Unable to edit workbook</p>
<p className="mt-1 text-muted-foreground">{loadError}</p>
<Button
type="button"
variant="outline"
size="sm"
className="mt-4"
onClick={() => fileInputRef.current?.click()}
>
<IconPlaceholder
lucide="Upload"
tabler="IconUpload"
hugeicons="Upload01Icon"
phosphor="UploadSimpleIcon"
remixicon="RiUpload2Line"
className="size-4"
/>
Upload XLSX
</Button>
</div>
</div>
</div>
)
}
if (!activeBuffer) {
return (
<div
className={cn(
"flex h-[640px] min-h-0 flex-col overflow-hidden bg-background",
className
)}
>
<input
ref={fileInputRef}
type="file"
accept=".xlsx,.xls,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,application/vnd.ms-excel"
className="hidden"
onChange={handleUpload}
/>
<EditorLoadingSurface showSpinner={shouldShowLoadingSpinner} />
</div>
)
}
return (
<div className={cn("overflow-hidden", className)}>
<input
ref={fileInputRef}
type="file"
accept=".xlsx,.xls,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,application/vnd.ms-excel"
className="hidden"
onChange={handleUpload}
/>
<XlsxWorkbookLoadedEditor
fileName={displayFileName}
isDark={effectiveIsDark}
onIsDarkChange={setNightRenderEnabled}
onUploadClick={() => fileInputRef.current?.click()}
renderTableHeaderMenu={(props) => (
<WorkbookTableHeaderMenu {...props} />
)}
showNightRenderToggle={shouldRenderNightMode}
workbookBuffer={activeBuffer}
workbookIdentity={workbookIdentity}
/>
</div>
)
}
function XlsxWorkbookLoadedEditor({
fileName,
isDark,
onIsDarkChange,
onUploadClick,
renderTableHeaderMenu,
showNightRenderToggle,
workbookBuffer,
workbookIdentity,
}: {
fileName: string
isDark: boolean
onIsDarkChange: (checked: boolean) => void
onUploadClick: () => void
renderTableHeaderMenu: (
props: XlsxTableHeaderMenuRenderProps
) => React.ReactNode
showNightRenderToggle: boolean
workbookBuffer: ArrayBuffer
workbookIdentity: string
}) {
const controller = useXlsxViewerController(
React.useMemo(
() => ({
allowResizeInReadOnly: true,
file: workbookBuffer,
fileName,
readOnly: false,
readOnlyAboveBytes: XLSX_EDITOR_READ_ONLY_THRESHOLD_BYTES,
useWorker: true,
}),
[fileName, workbookBuffer]
)
)
return (
<XlsxViewerProvider controller={controller} isDark={isDark}>
<XlsxEditorSurface
isDark={isDark}
onIsDarkChange={onIsDarkChange}
onUploadClick={onUploadClick}
renderTableHeaderMenu={renderTableHeaderMenu}
showNightRenderToggle={showNightRenderToggle}
workbookIdentity={workbookIdentity}
/>
</XlsxViewerProvider>
)
}