@persona/design-system 0.1.5-pre.4 → 0.1.6

package/dist/TableBox-CPCWzwSl.mjs

@@ -0,0 +1,1188 @@
+import { focusOutline } from "./mixins/focus.mjs";
+import "./variables/effect.mjs";
+import "./variables/transitions.mjs";
+import { paragraphMixins } from "./mixins/text.mjs";
+import { findIndexByKey, moveItemByIndex } from "./lib/reorderItems.mjs";
+import { useScrollOverflow } from "./lib/useScrollOverflow.mjs";
+import { Z_INDICES } from "./lib/zindex.mjs";
+import { n as Stack, t as HStack } from "./Stack-ckRN7LrP.mjs";
+import { t as IconButton } from "./IconButton-DC4rh6ow.mjs";
+import { t as FormGroupContext } from "./useFormGroup-z0epBxXn.mjs";
+import { s as MenuItem } from "./Menu-BbSyWxFD.mjs";
+import { n as DropdownMenu_default } from "./DropdownMenu-cN_AnKAT.mjs";
+import { n as CaretButton, t as Combobox } from "./Combobox-I44W5oX0.mjs";
+import { h as Table, m as TableHeaderCell, n as TableBody, p as TableRow, r as TableHead, s as TableCell } from "./Table-CGtyWI6V.mjs";
+import { s as Popover_default } from "./Popover-D4_aqKlm.mjs";
+import { t as Container } from "./FormControl-fK4HA_yF.mjs";
+import { BorderRadius, Color, Spacing, Typography } from "@persona/design-tokens";
+import styled, { css } from "styled-components";
+import { Children, cloneElement, createContext, isValidElement, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { DragIcon } from "@persona/icons";
+import { MoreIcon as MoreIcon$1, XIcon as XIcon$1 } from "@persona/icons/12px";
+import uniqueId from "lodash/fp/uniqueId.js";
+import { DndContext, DragOverlay, KeyboardSensor, PointerSensor, closestCenter, useSensor, useSensors } from "@dnd-kit/core";
+import { SortableContext, sortableKeyboardCoordinates, useSortable, verticalListSortingStrategy } from "@dnd-kit/sortable";
+//#region components/TableBox/tableBoxKeyboardNavigation.ts
+const INLINE_EDITOR_SELECTOR = "[data-tablebox-inline-edit-trigger], input[role=\"combobox\"]";
+const findInlineEditor = (cell) => cell?.querySelector(INLINE_EDITOR_SELECTOR) ?? null;
+const isCaretAtNavigationBoundary = (input, direction) => {
+	const { selectionStart, selectionEnd, value } = input;
+	if (selectionStart == null || selectionEnd == null || selectionStart !== selectionEnd) return false;
+	return direction === "left" ? selectionStart === 0 : selectionEnd === value.length;
+};
+const focusAdjacentInlineEditor = (target, direction) => {
+	const currentCell = target.closest("td");
+	const currentRow = currentCell?.closest("tr");
+	if (!(currentCell instanceof HTMLTableCellElement) || currentRow == null) return false;
+	if (direction === "up" || direction === "down") {
+		const adjacentRow = direction === "up" ? currentRow.previousElementSibling : currentRow.nextElementSibling;
+		if (!(adjacentRow instanceof HTMLTableRowElement)) return false;
+		const adjacentEditor = findInlineEditor(adjacentRow.cells.item(currentCell.cellIndex));
+		adjacentEditor?.focus();
+		return adjacentEditor != null;
+	}
+	let adjacentCell = direction === "left" ? currentCell.previousElementSibling : currentCell.nextElementSibling;
+	while (adjacentCell instanceof HTMLTableCellElement) {
+		const adjacentEditor = findInlineEditor(adjacentCell);
+		if (adjacentEditor != null) {
+			adjacentEditor.focus();
+			return true;
+		}
+		adjacentCell = direction === "left" ? adjacentCell.previousElementSibling : adjacentCell.nextElementSibling;
+	}
+	return false;
+};
+//#endregion
+//#region components/TableBox/InlineCombobox.tsx
+const StyledCombobox = styled(Combobox)`
+  border: none;
+  background-color: transparent;
+
+  /* Suppress the focus outline — it extends outside the input and is clipped
+     by the scroll container. Use && for specificity. */
+  && input,
+  && input:focus-visible:not(:disabled) {
+    outline: none;
+  }
+
+  ${({ $hideText }) => $hideText && `
+    input {
+      color: transparent;
+      caret-color: transparent;
+    }
+    input::placeholder {
+      color: transparent;
+    }
+  `}
+`;
+const ChildrenOverlay = styled.div`
+  position: absolute;
+  left: ${Spacing[2]};
+  top: 50%;
+  transform: translateY(-50%);
+  z-index: 1;
+  pointer-events: none;
+
+  // ${Spacing[5]} matches the sm ComboboxInput padding-right, keeping the text clear of the caret.
+  ${({ $truncate }) => $truncate && `
+    right: ${Spacing[5]};
+  `}
+`;
+const ComboboxWrapper = styled.div`
+  position: relative;
+  width: 100%;
+`;
+const InlineCombobox = ({ itemId, value, columnKey, inlineEditConfig, children, rowRef }) => {
+	const [isOpen, setIsOpen] = useState(false);
+	const context = useContext(TableBoxContext);
+	const onEditingChange = context?.onEditingChange;
+	const currentColumn = context?.columns?.find((c) => c.key === columnKey);
+	const placeholder = inlineEditConfig?.placeholder || currentColumn?.title || "";
+	const portalContainerRef = (inlineEditConfig?.fullWidthComboboxDropdown || false) && rowRef ? rowRef : void 0;
+	const showOverlay = !isOpen && !!children;
+	const handleOpenChange = useCallback((open) => {
+		setIsOpen(open);
+		onEditingChange?.(open);
+	}, [onEditingChange]);
+	return /* @__PURE__ */ jsxs(ComboboxWrapper, {
+		onKeyDownCapture: (event) => {
+			if (isOpen || event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
+			const direction = event.key === "ArrowLeft" ? "left" : "right";
+			if (!(event.target instanceof HTMLInputElement) || !isCaretAtNavigationBoundary(event.target, direction)) return;
+			if (focusAdjacentInlineEditor(event.currentTarget, direction)) {
+				event.preventDefault();
+				event.stopPropagation();
+			}
+		},
+		children: [showOverlay && /* @__PURE__ */ jsx(ChildrenOverlay, {
+			$truncate: inlineEditConfig?.truncateDisplay,
+			children
+		}), /* @__PURE__ */ jsx(StyledCombobox, {
+			$hideText: showOverlay,
+			value,
+			options: inlineEditConfig?.options || [],
+			onChange: (newValue) => {
+				if (inlineEditConfig?.onChange && newValue !== value && typeof newValue === "string") inlineEditConfig.onChange(itemId, newValue);
+			},
+			onOpenChange: handleOpenChange,
+			placeholder,
+			size: "sm",
+			portal: inlineEditConfig?.useComboboxPortal || false,
+			portalContainerRef
+		})]
+	});
+};
+//#endregion
+//#region components/TableBox/TableBoxRowContext.ts
+const TableBoxRowContext = createContext(null);
+//#endregion
+//#region components/TableBox/InlineInput.tsx
+const sharedInputStyles = css`
+  font: inherit;
+  color: inherit;
+  outline: none;
+  border: none;
+  padding: 0;
+  pointer-events: auto;
+  width: 100%;
+  background: transparent;
+  line-height: ${Typography.TextSmall.lineHeight};
+`;
+const InlineEditInput = styled.input`
+  ${sharedInputStyles}
+`;
+const InlineEditTextarea = styled.textarea`
+  ${sharedInputStyles}
+  resize: none;
+  overflow-y: auto;
+  min-height: ${Typography.TextSmall.lineHeight};
+  scrollbar-width: none;
+`;
+const InlineEditDisplay = styled.div`
+  cursor: text;
+  outline: none;
+  width: 100%;
+  height: 100%;
+  min-height: ${Typography.TextSmall.lineHeight};
+  line-height: ${Typography.TextSmall.lineHeight};
+
+  ${({ $multiline }) => $multiline ? css`
+          display: -webkit-box;
+          -webkit-line-clamp: 2;
+          -webkit-box-orient: vertical;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: pre-wrap;
+          word-break: break-word;
+        ` : css`
+          white-space: nowrap;
+          overflow: hidden;
+          text-overflow: ellipsis;
+        `}
+`;
+const InlineInput = ({ itemId, value, columnKey, inlineEditConfig, children }) => {
+	const { columns, newRowId, onEditingChange, scheduleCreateNewRowAfterCommit } = useContext(TableBoxContext) ?? {};
+	const rowContext = useContext(TableBoxRowContext);
+	const [isInlineEditing, setIsInlineEditing] = useState(itemId === newRowId && columnKey === columns?.[0]?.key);
+	const [editValue, setEditValue] = useState(value);
+	const inputRef = useRef(null);
+	const textareaRef = useRef(null);
+	const cancelledRef = useRef(false);
+	const isMultiline = inlineEditConfig?.multiline === true;
+	useEffect(() => {
+		return () => {
+			cancelledRef.current = false;
+		};
+	}, []);
+	useLayoutEffect(() => {
+		if (isInlineEditing && isMultiline && textareaRef.current) {
+			const textarea = textareaRef.current;
+			textarea.style.height = "auto";
+			textarea.style.height = `${textarea.scrollHeight}px`;
+		}
+	}, [
+		isInlineEditing,
+		editValue,
+		isMultiline
+	]);
+	useEffect(() => {
+		if (isInlineEditing && isMultiline && textareaRef.current) {
+			const length = textareaRef.current.value.length;
+			textareaRef.current.setSelectionRange(length, length);
+		}
+	}, [isInlineEditing, isMultiline]);
+	const placeholder = useMemo(() => {
+		const column = columns?.find((c) => c.key === columnKey);
+		return column?.inlineEditConfig?.placeholder || column?.title || "";
+	}, [columns, columnKey]);
+	const handleInlineEditKeyDown = (e) => {
+		const isFirstCell = columnKey === columns?.[0]?.key;
+		if ((e.key === "Delete" || e.key === "Backspace") && isFirstCell && editValue === "" && rowContext?.isBlank && rowContext.onDelete) {
+			e.preventDefault();
+			e.stopPropagation();
+			cancelledRef.current = true;
+			onEditingChange?.(false);
+			if (!(focusAdjacentInlineEditor(e.currentTarget, "down") || focusAdjacentInlineEditor(e.currentTarget, "up"))) e.currentTarget.closest("table")?.focus();
+			rowContext.onDelete();
+		} else if (!isMultiline && (e.key === "ArrowUp" || e.key === "ArrowDown" || e.key === "ArrowLeft" || e.key === "ArrowRight")) {
+			const direction = e.key === "ArrowUp" ? "up" : e.key === "ArrowDown" ? "down" : e.key === "ArrowLeft" ? "left" : "right";
+			if ((direction === "up" || direction === "down" || e.currentTarget instanceof HTMLInputElement && isCaretAtNavigationBoundary(e.currentTarget, direction)) && focusAdjacentInlineEditor(e.currentTarget, direction)) {
+				e.preventDefault();
+				e.stopPropagation();
+			}
+		} else if (e.key === "Enter") if (isMultiline) {
+			if (e.ctrlKey || e.metaKey) {
+				e.preventDefault();
+				e.stopPropagation();
+				handleInlineEditConfirm();
+				setIsInlineEditing(false);
+			}
+		} else {
+			e.preventDefault();
+			e.stopPropagation();
+			handleInlineEditConfirm();
+			setIsInlineEditing(false);
+			const isLastCell = columnKey === columns?.at(-1)?.key;
+			const currentRow = e.currentTarget.closest("tr");
+			const isLastRow = currentRow != null && currentRow.nextElementSibling == null;
+			if (isLastCell && isLastRow) scheduleCreateNewRowAfterCommit?.();
+		}
+		else if (e.key === "Tab") handleInlineEditConfirm();
+		else if (e.key === "Escape") {
+			e.preventDefault();
+			e.stopPropagation();
+			handleInlineEditCancel();
+		}
+	};
+	const handleInlineEditConfirm = () => {
+		if (inlineEditConfig?.onChange && editValue !== value) inlineEditConfig.onChange(itemId, editValue);
+	};
+	const handleInlineEditCancel = () => {
+		cancelledRef.current = true;
+		setEditValue(value);
+		setIsInlineEditing(false);
+		onEditingChange?.(false);
+	};
+	const handleInlineEditBlur = () => {
+		if (!cancelledRef.current) handleInlineEditConfirm();
+		cancelledRef.current = false;
+		setIsInlineEditing(false);
+		onEditingChange?.(false);
+	};
+	return isInlineEditing ? isMultiline ? /* @__PURE__ */ jsx(InlineEditTextarea, {
+		ref: textareaRef,
+		value: editValue,
+		onChange: (e) => setEditValue(e.target.value),
+		onBlur: handleInlineEditBlur,
+		onKeyDown: handleInlineEditKeyDown,
+		placeholder,
+		autoFocus: true,
+		rows: 1
+	}) : /* @__PURE__ */ jsx(InlineEditInput, {
+		ref: inputRef,
+		value: editValue,
+		onChange: (e) => setEditValue(e.target.value),
+		onBlur: handleInlineEditBlur,
+		onKeyDown: handleInlineEditKeyDown,
+		placeholder,
+		autoFocus: true
+	}) : /* @__PURE__ */ jsx(InlineEditDisplay, {
+		tabIndex: 0,
+		"data-tablebox-inline-edit-trigger": true,
+		$multiline: isMultiline,
+		onFocus: () => {
+			setEditValue(value);
+			onEditingChange?.(true);
+			setIsInlineEditing(true);
+		},
+		children: children || value
+	});
+};
+//#endregion
+//#region components/TableBox/TableBoxRowActions.tsx
+const IconButtonWidth = 16;
+const BackgroundFadeWidth = 12;
+const RowActionsContainerWithFadeWidth = BackgroundFadeWidth + (parseInt(Spacing[1]) + IconButtonWidth + parseInt(Spacing[2]));
+/**
+* Container for row-level actions (`actions` menu and/or delete `X`). Used
+* in two layouts:
+*
+* - **Dedicated trailing column** (`$inDedicatedColumn=true`, the default
+*   for horizontal-scroll mode): laid out in normal flow inside
+*   `PinnedActionsCell`.
+* - **Overlaid in last data cell** (`$inDedicatedColumn=false`,
+*   `disableHorizontalScroll` mode): absolutely positioned on top of the
+*   last cell's content with a fade gradient so it overlaps text on hover.
+*
+* Other variant props:
+* - `$hasCombobox` — last data column is an inline combobox; we use auto
+*   width so the caret↔first-action gap matches the action↔delete gap, and
+*   we drop the gradient so there's no fade running over the caret.
+* - `$hasDelete` — fade the container in only on hover, mirroring the
+*   legacy "show delete on hover" behavior.
+*/
+const RowActionsContainer = styled.div`
+  width: ${({ $hasCombobox }) => $hasCombobox ? "auto" : `${RowActionsContainerWithFadeWidth}px`};
+  position: ${({ $hasCombobox, $inDedicatedColumn }) => $hasCombobox || $inDedicatedColumn ? "static" : "absolute"};
+  right: ${Spacing[2]};
+  top: 0;
+  height: 100%;
+  display: flex;
+  gap: ${Spacing[1]};
+  align-items: center;
+  justify-content: end;
+  transition: opacity ${"200ms"} ease-out;
+  background: linear-gradient(
+    to right,
+    transparent,
+    ${Color.BackgroundPrimary} ${BackgroundFadeWidth}px
+  );
+
+  /* Combobox cells render actions inline next to the caret. The padding-left
+     keeps the caret↔first-action gap visually balanced with the gap between
+     the actions themselves. */
+  ${({ $hasCombobox }) => $hasCombobox && css`
+      background: none;
+      padding-right: ${Spacing[2]};
+      padding-left: ${Spacing[1]};
+    `}
+
+  /* PinnedActionsCell is transparent (so scrolling content can pass under it);
+     owning the right gutter here keeps the container's opaque gradient flush
+     to the cell's right edge. */
+  ${({ $inDedicatedColumn, $hasCombobox }) => $inDedicatedColumn && !$hasCombobox && css`
+      padding-right: ${Spacing[2]};
+    `}
+
+  /* Hide on hover only when delete is present (matches legacy behavior). */
+  ${({ $hasDelete }) => $hasDelete && css`
+      opacity: 0;
+    `}
+
+  /* Make room for both buttons; combobox cells use auto width so they can sit
+     inline next to the caret. */
+  ${({ $hasActions, $hasDelete, $hasCombobox }) => $hasActions && $hasDelete && !$hasCombobox && css`
+      width: ${RowActionsContainerWithFadeWidth + parseInt(Spacing[1]) + IconButtonWidth}px;
+    `}
+`;
+/**
+* Renders the actions menu and/or delete icon button inside a
+* `RowActionsContainer`. Used both as an absolute overlay inside the
+* last data cell (fixed-layout mode) and as static content inside the
+* dedicated sticky trailing column (horizontal scroll mode).
+*/
+const RowActions = ({ actions, onDelete, inDedicatedColumn, inCombobox }) => {
+	const hasActions = !!actions?.length;
+	if (!hasActions && !onDelete) return null;
+	return /* @__PURE__ */ jsxs(RowActionsContainer, {
+		$hasActions: hasActions,
+		$hasDelete: !!onDelete,
+		$hasCombobox: inCombobox,
+		$inDedicatedColumn: inDedicatedColumn,
+		onClick: (e) => e.stopPropagation(),
+		children: [hasActions && /* @__PURE__ */ jsx(DropdownMenu_default, {
+			portal: true,
+			trigger: /* @__PURE__ */ jsx(IconButton, {
+				"aria-label": "Actions",
+				children: /* @__PURE__ */ jsx(MoreIcon$1, {})
+			}),
+			children: actions?.map(({ label, onClick, ...rest }) => /* @__PURE__ */ jsx(MenuItem, {
+				...rest,
+				onClick,
+				size: "sm",
+				children: label
+			}, label))
+		}), onDelete && /* @__PURE__ */ jsx(IconButton, {
+			"aria-label": "Delete",
+			onClick: onDelete,
+			children: /* @__PURE__ */ jsx(XIcon$1, {})
+		})]
+	});
+};
+//#endregion
+//#region components/TableBox/TableBoxCell.tsx
+const CELL_VERTICAL_PADDING = Spacing[1];
+const CELL_HEIGHT = `calc(${Typography.TextSmall.lineHeight} + (${CELL_VERTICAL_PADDING} * 2))`;
+const StyledCell = styled(TableCell)`
+  ${paragraphMixins.sm};
+  // height acts as min-height for table cells
+  height: ${CELL_HEIGHT};
+  padding: ${({ $noPadding }) => $noPadding ? Spacing[0] : `${CELL_VERTICAL_PADDING} ${Spacing[2]}`};
+  border-bottom: 1px solid ${Color.BorderHairline};
+  position: relative;
+`;
+const StyledCellContent = styled.div`
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  flex-grow: 1;
+  min-width: 0;
+`;
+const TableBoxCell = ({ children, itemId = "", value = "", columnKey, isLastCell = false, actions, onDelete, inlineEditConfigOverride, ...props }) => {
+	const context = useContext(TableBoxContext);
+	const rowContext = useContext(TableBoxRowContext);
+	if (context == null) throw new Error("TableBox context is not set");
+	const columnConfig = context.columns.find((c) => c.key === columnKey)?.inlineEditConfig;
+	let inlineEditConfig = context.disabled || columnConfig == null ? void 0 : inlineEditConfigOverride ? {
+		...columnConfig,
+		...inlineEditConfigOverride
+	} : columnConfig;
+	if (inlineEditConfig?.type === "combobox" && (context.hasHorizontalOverflow || inlineEditConfig?.fullWidthComboboxDropdown)) inlineEditConfig = {
+		...inlineEditConfig,
+		useComboboxPortal: true
+	};
+	const handleDelete = () => {
+		if (onDelete && itemId) onDelete(itemId);
+	};
+	return /* @__PURE__ */ jsx(StyledCell, {
+		...props,
+		$noPadding: inlineEditConfig?.type === "combobox",
+		tabIndex: -1,
+		children: /* @__PURE__ */ jsxs(HStack, {
+			align: "center",
+			spacing: Spacing[0],
+			children: [inlineEditConfig ? inlineEditConfig.type === "combobox" ? /* @__PURE__ */ jsx(InlineCombobox, {
+				itemId,
+				value,
+				columnKey,
+				inlineEditConfig,
+				rowRef: rowContext?.rowRef,
+				children: /* @__PURE__ */ jsx(StyledCellContent, { children })
+			}) : /* @__PURE__ */ jsx(InlineInput, {
+				itemId,
+				value,
+				columnKey,
+				inlineEditConfig,
+				children
+			}) : /* @__PURE__ */ jsx(StyledCellContent, { children }), isLastCell && !context.disabled && /* @__PURE__ */ jsx(RowActions, {
+				actions,
+				onDelete: onDelete ? handleDelete : void 0,
+				inCombobox: inlineEditConfig?.type === "combobox"
+			})]
+		})
+	});
+};
+//#endregion
+//#region components/TableBox/TableBoxRow.tsx
+const StyledRow = styled(TableRow)`
+  cursor: ${({ $isSelectable }) => $isSelectable ? "pointer" : "default"};
+  position: relative;
+  /* Give every row a solid background so sticky first-column cells (which
+     inherit the row's background) remain opaque during horizontal scroll. */
+  background-color: ${Color.BackgroundPrimary};
+
+  /* Dim the dragged row in place. A floating clone rendered by @dnd-kit's
+     DragOverlay provides the fully-opaque representation that follows the
+     pointer. */
+  ${({ $isDragging }) => $isDragging && css`
+      opacity: 0.5;
+    `}
+
+  /* 2px brand-colored drop indicator applied to each cell via inset
+     box-shadow so the line spans the full row width without affecting
+     layout. box-shadow on <td> renders reliably across modern browsers,
+     unlike pseudo-elements on <tr>. */
+  ${({ $dropIndicatorPosition, theme }) => $dropIndicatorPosition === "top" && css`
+      td {
+        box-shadow: inset 0 2px 0 ${theme.color.text.brand};
+      }
+    `}
+
+  ${({ $dropIndicatorPosition, theme }) => $dropIndicatorPosition === "bottom" && css`
+      td {
+        box-shadow: inset 0 -2px 0 ${theme.color.text.brand};
+      }
+    `}
+
+  ${CaretButton} {
+    opacity: 0;
+    transition: opacity ${"200ms"} ease-out;
+
+    /* Allow button to shrink to caret SVG height and width, and adjust alignment to remain vertically centered */
+    width: auto;
+    height: auto;
+    top: 50%;
+    transform: translateY(-50%);
+  }
+
+  &:last-child {
+    td {
+      border-bottom: none;
+      &:first-child {
+        border-bottom-left-radius: ${BorderRadius.Md};
+      }
+      &:last-child {
+        border-bottom-right-radius: ${BorderRadius.Md};
+      }
+    }
+  }
+
+  &[aria-selected='true'] {
+    background: ${({ theme }) => theme.color.background.highlight};
+    color: ${({ theme }) => theme.color.text.brand};
+  }
+
+  &:hover:not([aria-selected='true']) {
+    cursor: ${({ $isSelectable }) => $isSelectable ? "pointer" : "default"};
+    color: ${({ theme }) => theme.color.text.primary};
+    background: ${Color.BackgroundSecondary};
+
+    ${RowActionsContainer} {
+      opacity: 1;
+      background: linear-gradient(to right, transparent, ${Color.BackgroundSecondary} 12px);
+    }
+
+    ${CaretButton} {
+      opacity: 1;
+    }
+  }
+
+  &:has(input:focus),
+  &:has(textarea:focus),
+  &:has(input[role='combobox'][aria-expanded='true']),
+  &:has(input:focus):hover,
+  &:has(textarea:focus):hover,
+  &:has(input[role='combobox'][aria-expanded='true']):hover,
+  &:has(button:focus),
+  &:has(button:focus):hover {
+    color: ${({ theme }) => theme.color.text.brand};
+    background-color: ${({ theme }) => theme.color.background.highlight};
+
+    ${RowActionsContainer} {
+      opacity: 1;
+      background: linear-gradient(
+        to right,
+        transparent,
+        ${({ theme }) => theme.color.background.highlight} ${parseInt(Spacing[3])}px
+      );
+    }
+
+    ${CaretButton} {
+      opacity: 1;
+    }
+  }
+`;
+const DragHandleCell = styled(TableCell)`
+  width: 24px;
+  padding: ${Spacing[0]} ${Spacing[1]};
+  border-bottom: 1px solid ${Color.BorderHairline};
+  vertical-align: middle;
+  text-align: center;
+`;
+const DragHandleButton = styled.button.attrs({ type: "button" })`
+  background: none;
+  border: none;
+  padding: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  cursor: grab;
+  touch-action: none;
+  color: ${Color.TextSecondary};
+  ${focusOutline}
+
+  &:hover {
+    color: ${Color.TextPrimary};
+  }
+
+  &:active {
+    cursor: grabbing;
+  }
+`;
+const DropdownPopoverHeading = styled.div`
+  ${Typography.TextSmallBold};
+  border-bottom: 1px solid ${Color.BorderHairline};
+  padding: ${Spacing[2]} ${Spacing[3]} ${Spacing[1]};
+`;
+const DropdownPopoverContent = styled(Stack)`
+  min-width: var(--radix-popover-trigger-width);
+  padding: ${Spacing[3]};
+
+  ${Container} {
+    min-width: 0;
+  }
+`;
+const DropdownPopoverFooter = styled.div`
+  border-top: 1px solid ${Color.BorderHairline};
+  padding: ${Spacing[1]};
+`;
+/**
+* Computes the drop-indicator position for a sortable row. Direction mirrors
+* `HoverCardPropertiesEditTable` / `ListBox`: dragging from above places the
+* line on the hovered row's bottom edge, dragging from below places it on the
+* top edge. The dragged row itself never shows an indicator.
+*
+* `closestCenter` has a "dead zone" while the pointer is still over the
+* dragged row's own slot (`overIndex === activeIndex`). We use the drag
+* direction to show the indicator on the immediate neighbor so the
+* "immediately before/after original" positions still get feedback.
+*/
+const getDropIndicatorPosition = ({ isDragging, index, activeIndex, overIndex, draggedDirection }) => {
+	if (isDragging || activeIndex === -1) return;
+	if (overIndex === index && overIndex !== activeIndex) return activeIndex < index ? "bottom" : "top";
+	if (overIndex === activeIndex) {
+		if (draggedDirection === "up" && index === activeIndex - 1) return "bottom";
+		if (draggedDirection === "down" && index === activeIndex + 1) return "top";
+	}
+};
+/**
+* Inner row component used when drag-and-drop is enabled on the parent
+* TableBox. Subscribes to the surrounding SortableContext via useSortable and
+* renders a leading drag-handle cell.
+*/
+const SortableTableBoxRowContent = ({ id, isSelected, isSelectable, onClick, rowRef, draggedDirection, children, ...props }) => {
+	const { attributes, listeners, setNodeRef, isDragging, activeIndex, overIndex, index } = useSortable({ id: String(id) });
+	const setRefs = (element) => {
+		rowRef.current = element;
+		setNodeRef(element);
+	};
+	const dropIndicatorPosition = getDropIndicatorPosition({
+		isDragging,
+		index,
+		activeIndex,
+		overIndex,
+		draggedDirection
+	});
+	return /* @__PURE__ */ jsxs(StyledRow, {
+		...props,
+		ref: setRefs,
+		id: String(id),
+		onClick,
+		disableHoverBackground: true,
+		"aria-selected": isSelected,
+		$isSelectable: isSelectable,
+		$isDragging: isDragging,
+		$dropIndicatorPosition: dropIndicatorPosition,
+		children: [/* @__PURE__ */ jsx(DragHandleCell, { children: /* @__PURE__ */ jsx(DragHandleButton, {
+			"aria-label": "Drag to reorder",
+			...attributes,
+			...listeners,
+			onClick: (e) => e.stopPropagation(),
+			children: /* @__PURE__ */ jsx(DragIcon, {})
+		}) }), children]
+	});
+};
+const TableBoxRow = ({ children, actions, onDelete, id, dropdownFormFields, dropdownContent, dropdownHeadingText, dropdownFooter, ...props }) => {
+	const context = useContext(TableBoxContext);
+	const isSelected = context?.selectedKey === id;
+	const isSelectable = context?.selectionMode === "single";
+	const isReorderable = context?.isReorderable ?? false;
+	const rowRegistry = context?.rowRegistry ?? null;
+	const draggedDirection = context?.draggedDirection ?? null;
+	const hasActionsColumn = context?.hasActionsColumn ?? false;
+	const isDisabled = context?.disabled ?? false;
+	const rowRef = useRef(null);
+	const effectiveActions = isDisabled ? void 0 : actions;
+	const effectiveOnDelete = isDisabled ? void 0 : onDelete;
+	const isBlank = Children.toArray(children).every((child) => isValidElement(child) && child.props.value === "");
+	const handleClick = () => {
+		if (context?.onRowClick && id && isSelectable) context.onRowClick(id);
+	};
+	const handleDelete = useCallback(() => {
+		if (effectiveOnDelete && id != null) effectiveOnDelete(id);
+	}, [effectiveOnDelete, id]);
+	const rowContextValue = useMemo(() => ({
+		rowRef,
+		onDelete: effectiveOnDelete && id != null ? handleDelete : void 0,
+		isBlank
+	}), [
+		effectiveOnDelete,
+		handleDelete,
+		id,
+		isBlank
+	]);
+	const lastColumnIsCombobox = context?.columns?.at(-1)?.inlineEditConfig?.type === "combobox";
+	const trailingActionsCell = useMemo(() => hasActionsColumn ? /* @__PURE__ */ jsx(PinnedActionsCell, { children: /* @__PURE__ */ jsx(RowActions, {
+		actions: effectiveActions,
+		onDelete: effectiveOnDelete ? handleDelete : void 0,
+		inDedicatedColumn: true,
+		inCombobox: lastColumnIsCombobox
+	}) }) : null, [
+		hasActionsColumn,
+		effectiveActions,
+		effectiveOnDelete,
+		handleDelete,
+		lastColumnIsCombobox
+	]);
+	const renderedChildren = useMemo(() => {
+		if (hasActionsColumn) return children;
+		const childrenArray = Array.isArray(children) ? children : [children];
+		const lastChildIndex = childrenArray.length - 1;
+		return childrenArray.map((child, index) => {
+			if (!isValidElement(child) || index !== lastChildIndex) return child;
+			return cloneElement(child, {
+				isLastCell: true,
+				actions: effectiveActions,
+				onDelete: effectiveOnDelete,
+				...id != null && { itemId: String(id) }
+			});
+		});
+	}, [
+		hasActionsColumn,
+		children,
+		effectiveActions,
+		effectiveOnDelete,
+		id
+	]);
+	const rowChildrenWithContext = useMemo(() => /* @__PURE__ */ jsxs(TableBoxRowContext.Provider, {
+		value: rowContextValue,
+		children: [renderedChildren, trailingActionsCell]
+	}), [
+		renderedChildren,
+		trailingActionsCell,
+		rowContextValue
+	]);
+	useEffect(() => {
+		if (!rowRegistry || id == null) return;
+		const key = String(id);
+		const registry = rowRegistry.current;
+		registry.set(key, rowChildrenWithContext);
+		return () => {
+			registry.delete(key);
+		};
+	}, [
+		id,
+		rowChildrenWithContext,
+		rowRegistry
+	]);
+	const shouldRenderDropdown = dropdownFormFields || dropdownContent;
+	const rowContent = isReorderable ? /* @__PURE__ */ jsx(SortableTableBoxRowContent, {
+		...props,
+		id,
+		isSelected,
+		isSelectable,
+		onClick: handleClick,
+		rowRef,
+		draggedDirection,
+		children: rowChildrenWithContext
+	}) : /* @__PURE__ */ jsx(StyledRow, {
+		...props,
+		ref: rowRef,
+		id,
+		onClick: handleClick,
+		disableHoverBackground: true,
+		"aria-selected": isSelected,
+		$isSelectable: isSelectable,
+		children: rowChildrenWithContext
+	});
+	if (shouldRenderDropdown) return /* @__PURE__ */ jsx(Popover_default, {
+		trigger: rowContent,
+		open: isSelected,
+		children: /* @__PURE__ */ jsxs(Popover_default.Card, {
+			id: context?.rowDropdownId,
+			noPadding: true,
+			style: { zIndex: Z_INDICES.modalDropdown },
+			children: [
+				dropdownHeadingText && /* @__PURE__ */ jsx(DropdownPopoverHeading, { children: dropdownHeadingText }),
+				dropdownFormFields && /* @__PURE__ */ jsx(DropdownPopoverContent, {
+					spacing: Spacing[2],
+					children: /* @__PURE__ */ jsx(FormGroupContext.Provider, {
+						value: {
+							configField: true,
+							labelTooltipZIndex: Z_INDICES.modalDropdownTooltip
+						},
+						children: dropdownFormFields
+					})
+				}),
+				dropdownContent && /* @__PURE__ */ jsx(DropdownPopoverContent, {
+					spacing: Spacing[3],
+					children: dropdownContent
+				}),
+				dropdownFooter && /* @__PURE__ */ jsx(DropdownPopoverFooter, { children: dropdownFooter })
+			]
+		})
+	});
+	return rowContent;
+};
+const OverlayTable = styled.table`
+  width: 100%;
+  table-layout: fixed;
+  border-collapse: separate;
+  border-spacing: 0;
+  border: 1px solid ${Color.BorderDivider};
+  border-radius: ${BorderRadius.Md};
+  background: ${Color.BackgroundPrimary};
+  box-shadow: ${"0px 2px 10px 0px rgba(0, 0, 0, 0.04), 0px 5px 20px 0px rgba(0, 0, 0, 0.06), 0px 10px 40px 0px rgba(0, 0, 0, 0.08)"};
+`;
+/**
+* Visual clone of a `TableBoxRow` used inside `@dnd-kit`'s `DragOverlay`.
+* Renders a minimal table wrapper with a static drag-handle cell followed by
+* the original row's cells, so the portaled overlay looks identical to the
+* dragged row while it follows the pointer.
+*
+* `cellWidths` is the measured width (in px) of each `<td>` in the source
+* row at drag start, in source order (drag handle cell first, then content
+* cells). Applied via a `<colgroup>` with `table-layout: fixed` so the
+* overlay's columns align 1:1 with the source table instead of re-flowing
+* to the single row's content.
+*/
+const TableBoxRowOverlay = ({ children, cellWidths }) => /* @__PURE__ */ jsxs(OverlayTable, {
+	"aria-hidden": "true",
+	children: [/* @__PURE__ */ jsx("colgroup", { children: cellWidths.map((width, i) => /* @__PURE__ */ jsx("col", { style: { width: `${width}px` } }, i)) }), /* @__PURE__ */ jsx("tbody", { children: /* @__PURE__ */ jsxs(StyledRow, {
+		disableHoverBackground: true,
+		children: [/* @__PURE__ */ jsx(DragHandleCell, { children: /* @__PURE__ */ jsx(DragHandleButton, {
+			tabIndex: -1,
+			"aria-hidden": "true",
+			children: /* @__PURE__ */ jsx(DragIcon, {})
+		}) }), children]
+	}) })]
+});
+//#endregion
+//#region components/TableBox/useColumnWidthLock.ts
+/**
+* Captures the live `<th>` widths of a table the moment inline editing starts
+* and clears them when editing ends.
+*
+* Consumers render a `<colgroup>` from `lockedColWidths` and switch the table
+* to `table-layout: fixed` for the duration of the edit so the input swap
+* doesn't reflow the columns.
+*/
+const useColumnWidthLock = (tableRef, { enabled = true } = {}) => {
+	const [lockedColWidths, setLockedColWidths] = useState(null);
+	return {
+		lockedColWidths,
+		onEditingChange: useCallback((isEditing) => {
+			if (!enabled) return;
+			if (!isEditing) {
+				setLockedColWidths(null);
+				return;
+			}
+			const ths = Array.from(tableRef.current?.querySelectorAll(":scope > thead > tr > th") ?? []);
+			if (ths.length > 0) setLockedColWidths(ths.map((th) => th.getBoundingClientRect().width));
+		}, [tableRef, enabled])
+	};
+};
+//#endregion
+//#region components/TableBox/useTableBoxDragAndDrop.ts
+const DRAG_DIRECTION_THRESHOLD = 4;
+/**
+* Bundles the `@dnd-kit` wiring TableBox needs to support row reordering:
+* sensors, lifecycle handlers, the dragged row's overlay content, and the
+* pointer direction used by rows to position drop indicators in dnd-kit's
+* "dead zone" (overIndex === activeIndex).
+*
+* Also forces a `grabbing` cursor on `<body>` while a row is active so the
+* cursor persists when the pointer leaves the drag handle.
+*/
+const useTableBoxDragAndDrop = ({ tableRef, reorderConfig }) => {
+	const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }));
+	const rowRegistry = useRef(/* @__PURE__ */ new Map());
+	const [activeId, setActiveId] = useState(null);
+	const [draggedDirection, setDraggedDirection] = useState(null);
+	const [overlayCellWidths, setOverlayCellWidths] = useState(null);
+	useEffect(() => {
+		if (activeId == null) return;
+		const previous = document.body.style.cursor;
+		document.body.style.cursor = "grabbing";
+		return () => {
+			document.body.style.cursor = previous;
+		};
+	}, [activeId]);
+	const sortableIds = useMemo(() => {
+		if (!reorderConfig) return [];
+		return reorderConfig.items.map((item) => String(item[reorderConfig.itemKeyPath]));
+	}, [reorderConfig]);
+	const handleDragStart = useCallback((event) => {
+		const id = String(event.active.id);
+		setActiveId(id);
+		setDraggedDirection(null);
+		const rowElement = tableRef.current?.querySelector(`tr[id="${CSS.escape(id)}"]`);
+		if (rowElement) setOverlayCellWidths(Array.from(rowElement.children).filter((child) => child.tagName === "TD").map((td) => td.getBoundingClientRect().width));
+		else setOverlayCellWidths(null);
+	}, [tableRef]);
+	const handleDragMove = useCallback((event) => {
+		const { y } = event.delta;
+		const next = y < -DRAG_DIRECTION_THRESHOLD ? "up" : y > DRAG_DIRECTION_THRESHOLD ? "down" : null;
+		setDraggedDirection((prev) => prev === next ? prev : next);
+	}, []);
+	const resetDragState = useCallback(() => {
+		setActiveId(null);
+		setDraggedDirection(null);
+		setOverlayCellWidths(null);
+	}, []);
+	return {
+		activeId,
+		overlayCellWidths,
+		draggedDirection,
+		sortableIds,
+		rowRegistry,
+		dndContextProps: {
+			sensors,
+			collisionDetection: closestCenter,
+			onDragStart: handleDragStart,
+			onDragMove: handleDragMove,
+			onDragEnd: useCallback((event) => {
+				resetDragState();
+				if (!reorderConfig) return;
+				const { active, over } = event;
+				if (!over || active.id === over.id) return;
+				const { items, itemKeyPath, onReorder } = reorderConfig;
+				const fromIndex = findIndexByKey(items, itemKeyPath, String(active.id));
+				const toIndex = findIndexByKey(items, itemKeyPath, String(over.id));
+				if (fromIndex === -1 || toIndex === -1) return;
+				onReorder(moveItemByIndex(items, fromIndex, toIndex));
+			}, [reorderConfig, resetDragState]),
+			onDragCancel: resetDragState
+		}
+	};
+};
+//#endregion
+//#region components/TableBox/TableBox.tsx
+const TableBoxContext = createContext(null);
+const DRAG_HANDLE_CELL_WIDTH = 24;
+const RIGHT_FADE_WIDTH = 48;
+const HEADER_HEIGHT_PX = parseInt(Spacing[1], 10) * 2 + parseInt(Typography.TextSmall.lineHeight, 10) + 1;
+const TableScrollContainer = styled.div`
+  border: 1px solid ${Color.BorderDivider};
+  border-radius: ${BorderRadius.Md};
+  overflow-x: ${({ $fixedLayout, $hasHorizontalOverflow }) => $fixedLayout ? "visible" : $hasHorizontalOverflow ? "auto" : "visible"};
+  overscroll-behavior-x: none;
+`;
+const ScrollAffordanceWrapper = styled.div`
+  position: relative;
+`;
+const RightFadeOverlay = styled.div`
+  position: absolute;
+  top: 1px;
+  right: 1px;
+  bottom: 1px;
+  width: ${RIGHT_FADE_WIDTH}px;
+  /* Sits above the sticky first column (z-index 2) but below the pinned
+     row actions (z-index 4) so action buttons stay legible. */
+  z-index: 3;
+  pointer-events: none;
+  background:
+    linear-gradient(to right, transparent, ${Color.BackgroundSecondary}) top left / 100%
+      ${Math.max(0, HEADER_HEIGHT_PX - 1)}px no-repeat,
+    linear-gradient(to right, transparent, ${Color.BackgroundPrimary}) bottom left / 100%
+      calc(100% - ${HEADER_HEIGHT_PX}px) no-repeat;
+  border-top-right-radius: ${BorderRadius.Md};
+  border-bottom-right-radius: ${BorderRadius.Md};
+  opacity: ${({ $visible }) => $visible ? 1 : 0};
+  transition: opacity ${"200ms"} ease-out;
+`;
+const stickyContentColumn = (isReorderable) => css`
+  && thead th:first-child,
+  && tbody td:first-child {
+    position: sticky;
+    left: 0;
+    z-index: 2;
+  }
+
+  && tbody td:first-child {
+    background-color: inherit;
+  }
+
+  ${isReorderable && css`
+    && thead th:nth-child(2),
+    && tbody td:nth-child(2) {
+      position: sticky;
+      left: ${DRAG_HANDLE_CELL_WIDTH}px;
+      z-index: 2;
+    }
+
+    && tbody td:nth-child(2) {
+      background-color: inherit;
+    }
+  `}
+`;
+const StyledTable = styled(Table)`
+  caret-color: ${Color.BorderFocus};
+
+  &::selection {
+    background: ${Color.BackgroundLabelPurple};
+  }
+
+  ${({ $fixedLayout, $isReorderable }) => $fixedLayout ? css`
+          /* Legacy: truncate long cell content to container width. */
+          table-layout: fixed;
+        ` : stickyContentColumn($isReorderable)}
+
+  /* Lock column widths while inline editing to prevent layout reflow. */
+  ${({ $fixedLayout, $lockedWidth }) => !$fixedLayout && $lockedWidth != null && css`
+      table-layout: fixed;
+      width: ${$lockedWidth}px;
+    `}
+
+  /* Subtle right border on the sticky column when content extends off-screen
+     — inset shadow keeps it layout-neutral. */
+  ${({ $hasHorizontalOverflow, $isReorderable, $fixedLayout }) => $hasHorizontalOverflow && !$fixedLayout && css`
+      ${$isReorderable ? `&& thead th:nth-child(2), && tbody td:nth-child(2)` : `&& thead th:first-child, && tbody td:first-child`} {
+        box-shadow: inset -1px 0 0 ${Color.BorderDivider};
+      }
+    `}
+
+  /* When the header is hidden, round the first body row's outer corners so
+     they line up with the surrounding container's rounded border. */
+  ${({ $hideHeader }) => $hideHeader && css`
+      && tbody tr:first-child td:first-child {
+        border-top-left-radius: ${BorderRadius.Md};
+      }
+      && tbody tr:first-child td:last-child {
+        border-top-right-radius: ${BorderRadius.Md};
+      }
+    `}
+`;
+const StyledTableHeaderCell = styled(TableHeaderCell)`
+  padding: ${Spacing[1]} ${Spacing[2]};
+  border-bottom: 1px solid ${Color.BorderDivider};
+  ${paragraphMixins.sm};
+
+  /* Border radius for corner cells */
+  &:first-child {
+    border-radius: ${BorderRadius.Md} 0 0 0;
+  }
+
+  &:last-child {
+    border-radius: 0 ${BorderRadius.Md} 0 0;
+  }
+`;
+const DragHandleHeaderCell = styled(StyledTableHeaderCell)`
+  width: 24px;
+  padding: ${Spacing[1]} ${Spacing[0]};
+`;
+const PinnedActionsCell = styled(TableCell)`
+  position: sticky;
+  right: 0;
+  z-index: 4;
+  background: transparent;
+  border-bottom: 1px solid ${Color.BorderHairline};
+  padding: 0;
+  width: ${RowActionsContainerWithFadeWidth}px;
+  height: 1px; /* dummy height lets the child use height: 100% */
+`;
+const EmptyStateCell = styled(TableCell)`
+  ${paragraphMixins.sm};
+  padding: ${Spacing[2]};
+  color: ${Color.TextSecondary};
+  border-bottom: none;
+`;
+const TableBox = ({ children, emptyText, selectedKey, defaultSelectedKey, columns, onSelectionChange, selectionMode = "none", newRowId, onCreateNewRow: onCreateNewRowProp, disabled = false, reorderConfig, disableHorizontalScroll: disableHorizontalScrollProp = false, hideHeader = false, "aria-label": ariaLabel, ...props }) => {
+	const tableRef = useRef(null);
+	const scrollContainerRef = useRef(null);
+	const tableBoxId = useMemo(() => uniqueId("tablebox-"), []);
+	const rowDropdownId = `${tableBoxId}-row-dropdown`;
+	const hasInlineEditableColumn = columns.some((c) => c.inlineEditConfig != null);
+	const disableHorizontalScroll = disableHorizontalScrollProp || hasInlineEditableColumn;
+	const { hasHorizontalOverflow, hasMoreScrollRight } = useScrollOverflow(scrollContainerRef, { enabled: !disableHorizontalScroll });
+	const { lockedColWidths, onEditingChange } = useColumnWidthLock(tableRef, { enabled: !disableHorizontalScroll });
+	const [internalSelectedKey, setInternalSelectedKey] = useState(defaultSelectedKey ?? null);
+	const [shouldCreateNewRowAfterCommit, setShouldCreateNewRowAfterCommit] = useState(false);
+	const currentSelectedKey = selectedKey ?? internalSelectedKey;
+	const scheduleCreateNewRowAfterCommit = () => {
+		setShouldCreateNewRowAfterCommit(true);
+	};
+	const handleRowClick = useCallback((rowId) => {
+		if (selectionMode === "none") return;
+		if (!onSelectionChange) setInternalSelectedKey(rowId);
+		else onSelectionChange(rowId);
+	}, [onSelectionChange, selectionMode]);
+	const handleOutsideClick = useCallback((event) => {
+		if (!document.querySelector(`[id="${rowDropdownId}"][data-state="open"]`)) return;
+		const target = event.target;
+		const isOutsideTableBox = tableRef.current && !tableRef.current.contains(target);
+		const isOnRowDropdownContent = target.closest(`[id="${rowDropdownId}"]`);
+		if (isOutsideTableBox && !isOnRowDropdownContent && currentSelectedKey != null) if (!onSelectionChange) setInternalSelectedKey(null);
+		else onSelectionChange(null);
+	}, [
+		currentSelectedKey,
+		onSelectionChange,
+		rowDropdownId
+	]);
+	useEffect(() => {
+		document.addEventListener("mousedown", handleOutsideClick);
+		return () => {
+			document.removeEventListener("mousedown", handleOutsideClick);
+		};
+	}, [handleOutsideClick]);
+	useEffect(() => {
+		if (!shouldCreateNewRowAfterCommit) return;
+		setShouldCreateNewRowAfterCommit(false);
+		onCreateNewRowProp?.();
+	}, [onCreateNewRowProp, shouldCreateNewRowAfterCommit]);
+	const { activeId, overlayCellWidths, draggedDirection, sortableIds, rowRegistry, dndContextProps } = useTableBoxDragAndDrop({
+		tableRef,
+		reorderConfig: disabled ? void 0 : reorderConfig
+	});
+	const isReorderable = !disabled && reorderConfig != null;
+	const hasActionsColumn = !disableHorizontalScroll;
+	const contextValue = {
+		disabled,
+		newRowId,
+		columns,
+		selectedKey: currentSelectedKey,
+		selectionMode,
+		onRowClick: handleRowClick,
+		tableBoxId,
+		rowDropdownId,
+		isReorderable,
+		rowRegistry: isReorderable ? rowRegistry : null,
+		draggedDirection,
+		hasActionsColumn,
+		hasHorizontalOverflow,
+		onEditingChange,
+		scheduleCreateNewRowAfterCommit: onCreateNewRowProp ? scheduleCreateNewRowAfterCommit : void 0
+	};
+	const isEmpty = Array.isArray(children) ? children.length === 0 : children == null;
+	const totalColumnCount = columns.length + (isReorderable ? 1 : 0) + (hasActionsColumn ? 1 : 0);
+	const activeRowContent = activeId ? rowRegistry.current.get(activeId) ?? null : null;
+	const tableContent = /* @__PURE__ */ jsxs(ScrollAffordanceWrapper, { children: [/* @__PURE__ */ jsx(TableScrollContainer, {
+		ref: scrollContainerRef,
+		$fixedLayout: disableHorizontalScroll,
+		$hasHorizontalOverflow: hasHorizontalOverflow,
+		children: /* @__PURE__ */ jsxs(StyledTable, {
+			ref: tableRef,
+			size: "md",
+			"aria-label": ariaLabel,
+			tabIndex: -1,
+			$isReorderable: isReorderable,
+			$hasHorizontalOverflow: hasHorizontalOverflow,
+			$fixedLayout: disableHorizontalScroll,
+			$hideHeader: hideHeader,
+			$lockedWidth: lockedColWidths != null ? lockedColWidths.reduce((sum, w) => sum + w, 0) : void 0,
+			...props,
+			children: [
+				lockedColWidths && /* @__PURE__ */ jsx("colgroup", { children: lockedColWidths.map((w, i) => /* @__PURE__ */ jsx("col", { style: { width: `${w}px` } }, i)) }),
+				!hideHeader && /* @__PURE__ */ jsx(TableHead, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+					isReorderable && /* @__PURE__ */ jsx(DragHandleHeaderCell, { "aria-hidden": "true" }),
+					columns.map((column) => /* @__PURE__ */ jsx(StyledTableHeaderCell, { children: column.title }, column.key)),
+					hasActionsColumn && /* @__PURE__ */ jsx(StyledTableHeaderCell, {
+						"aria-hidden": "true",
+						style: { padding: 0 }
+					})
+				] }) }),
+				/* @__PURE__ */ jsx(TableBody, { children: isEmpty ? /* @__PURE__ */ jsx(TableRow, {
+					disableHoverBackground: true,
+					children: /* @__PURE__ */ jsx(EmptyStateCell, {
+						colSpan: totalColumnCount,
+						children: emptyText || "No data available."
+					})
+				}) : children })
+			]
+		})
+	}), !disableHorizontalScroll && /* @__PURE__ */ jsx(RightFadeOverlay, {
+		"aria-hidden": "true",
+		$visible: hasMoreScrollRight
+	})] });
+	return /* @__PURE__ */ jsx(TableBoxContext.Provider, {
+		value: contextValue,
+		children: isReorderable ? /* @__PURE__ */ jsxs(DndContext, {
+			...dndContextProps,
+			children: [/* @__PURE__ */ jsx(SortableContext, {
+				items: sortableIds,
+				strategy: verticalListSortingStrategy,
+				children: tableContent
+			}), /* @__PURE__ */ jsx(DragOverlay, { children: activeRowContent && overlayCellWidths && /* @__PURE__ */ jsx(TableBoxRowOverlay, {
+				cellWidths: overlayCellWidths,
+				children: activeRowContent
+			}) })]
+		}) : tableContent
+	});
+};
+TableBox.Row = TableBoxRow;
+TableBox.Cell = TableBoxCell;
+//#endregion
+export { TableBoxContext as n, TableBox as t };
+
+//# sourceMappingURL=TableBox-CPCWzwSl.mjs.map