@galaxy-io/dls 1.2.6 → 1.3.0

package/dist/{spreadsheet → table}/SpreadsheetCell.d.ts

@@ -1,19 +1,21 @@
 import React from "react";
-import { ColumnAlign, ColumnPin, type SpreadsheetColumnDef } from "./types";
+import { ColumnAlign, ColumnPin, TableDensity, TableVariant, type SpreadsheetColumnDef } from "./types";
 export interface SpreadsheetCellProps<TData> {
     column: SpreadsheetColumnDef<TData, unknown>;
     row: TData;
     rowIndex: number;
+    columnIndex: number;
     isEditing: boolean;
     onStartEditing: () => void;
     onCommit: (value: unknown) => void;
     onCancel: () => void;
-    width: number;
+    width?: number;
     pin?: ColumnPin;
     pinnedOffset?: number;
     align?: ColumnAlign;
-    density: string;
+    density: TableDensity;
+    variant: TableVariant;
 }
-declare function SpreadsheetCellInner<TData>({ column, row, rowIndex, isEditing, onStartEditing, onCommit, onCancel, width, pin, pinnedOffset, align, }: SpreadsheetCellProps<TData>): React.JSX.Element;
+declare function SpreadsheetCellInner<TData>({ column, row, rowIndex, columnIndex, isEditing, onStartEditing, onCommit, onCancel, width, pin, pinnedOffset, align, density, variant, }: SpreadsheetCellProps<TData>): React.JSX.Element;
 declare const SpreadsheetCell: typeof SpreadsheetCellInner;
 export default SpreadsheetCell;

package/dist/table/SpreadsheetCell.js

@@ -0,0 +1,71 @@
+import Text, { TextSize, TextVariant } from "../text/Text.js";
+import { CellEnrichmentStatus, SpreadsheetCellType } from "./types.js";
+import { createVirtualRow } from "./utils.js";
+import { TableDataCell } from "./TablePrimitives.js";
+import { CellStatusDot } from "./SpreadsheetPrimitives.js";
+import SpreadsheetCellEditor from "./SpreadsheetCellEditor.js";
+import { match } from "ts-pattern";
+import React, { useCallback } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/table/SpreadsheetCell.tsx
+function formatDisplayValue(value, cellType) {
+	if (value === null || value === void 0 || value === "") return "—";
+	return match(cellType).with(SpreadsheetCellType.BOOLEAN, () => value ? "Yes" : "No").with(SpreadsheetCellType.DATE, () => {
+		if (value instanceof Date) return value.toLocaleDateString();
+		return String(value);
+	}).otherwise(() => String(value));
+}
+function SpreadsheetCellInner({ column, row, rowIndex, columnIndex, isEditing, onStartEditing, onCommit, onCancel, width, pin, pinnedOffset, align, density, variant }) {
+	const value = column.accessorFn ? column.accessorFn(row) : void 0;
+	const isEditable = column.editable !== false && column.cellType !== SpreadsheetCellType.READONLY;
+	const enrichmentStatus = column.getCellEnrichmentStatus?.(row, rowIndex) ?? CellEnrichmentStatus.IDLE;
+	const showStatusDot = enrichmentStatus !== CellEnrichmentStatus.IDLE;
+	const handleClick = useCallback(() => {
+		if (isEditable && !isEditing) onStartEditing();
+	}, [
+		isEditable,
+		isEditing,
+		onStartEditing
+	]);
+	const renderContent = () => {
+		if (column.cell) return column.cell({
+			value,
+			row: createVirtualRow(row, rowIndex),
+			isEditing
+		});
+		if (isEditing) return /* @__PURE__ */ jsx(SpreadsheetCellEditor, {
+			cellType: column.cellType,
+			value,
+			enumOptions: column.enumOptions,
+			onCommit,
+			onCancel
+		});
+		return /* @__PURE__ */ jsxs(Fragment, { children: [showStatusDot && /* @__PURE__ */ jsx(CellStatusDot, { $status: enrichmentStatus }), /* @__PURE__ */ jsx(Text, {
+			variant: TextVariant.PRIMARY,
+			size: TextSize.BODY_SM,
+			isEllipsis: true,
+			children: formatDisplayValue(value, column.cellType)
+		})] });
+	};
+	return /* @__PURE__ */ jsx(TableDataCell, {
+		$width: width,
+		$minWidth: column.minSize,
+		$maxWidth: column.maxSize,
+		$pin: pin,
+		$pinnedOffset: pinnedOffset,
+		$align: align,
+		$density: density,
+		$variant: variant,
+		$isPositioned: true,
+		$isEditable: isEditable,
+		"data-editable": isEditable ? "true" : void 0,
+		role: "gridcell",
+		"aria-colindex": columnIndex + 1,
+		"aria-readonly": isEditable ? void 0 : true,
+		onClick: handleClick,
+		children: renderContent()
+	});
+}
+var SpreadsheetCell = React.memo(SpreadsheetCellInner);
+//#endregion
+export { SpreadsheetCell as default };

package/dist/{spreadsheet → table}/SpreadsheetCellEditor.js

@@ -1,37 +1,43 @@
-import { withTheme } from "../theme/GalaxyTheme.js";
 import { SpreadsheetCellType } from "./types.js";
+import { CellEditorWrapper } from "./SpreadsheetPrimitives.js";
 import SelectInput from "../inputs/SelectInput.js";
 import DateInput from "../inputs/DateInput.js";
 import NumberInput from "../inputs/NumberInput.js";
 import TextInput from "../inputs/TextInput.js";
 import ToggleInput from "../inputs/ToggleInput.js";
-/* empty css                                */
-import { styled } from "@linaria/react";
 import { match } from "ts-pattern";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
-//#region src/spreadsheet/SpreadsheetCellEditor.tsx
-var _exp = () => ({ theme }) => theme.color.background.primary;
-var _exp2 = () => ({ theme }) => theme.color.background.galaxy;
-var EditorWrapper = withTheme(/*#__PURE__*/ styled("div")({
-	name: "EditorWrapper",
-	class: "ejxsxoj",
-	propsAsIs: false,
-	vars: {
-		"ejxsxoj-0": [_exp()],
-		"ejxsxoj-1": [_exp2()]
-	}
-}));
+//#region src/table/SpreadsheetCellEditor.tsx
+/**
+* `Dropdown` renders through a Tippy portal on `document.body`, so an option
+* list is not a DOM descendant of the editor. Tippy marks its portal root with
+* this attribute — without the check, pressing an option counts as an outside
+* press, commits, and unmounts the editor before the click can land.
+*/
+var TIPPY_PORTAL_SELECTOR = "[data-tippy-root]";
+function isInsidePortal(target) {
+	return target instanceof Element && target.closest(TIPPY_PORTAL_SELECTOR) !== null;
+}
 function SpreadsheetCellEditor({ cellType, value, enumOptions, onCommit, onCancel }) {
 	const wrapperRef = useRef(null);
 	const [localValue, setLocalValue] = useState(value);
+	const commitRef = useRef(() => {});
+	useEffect(() => {
+		commitRef.current = () => onCommit(localValue);
+	});
 	useEffect(() => {
-		const handleClickOutside = (e) => {
-			if (wrapperRef.current && !wrapperRef.current.contains(e.target)) onCommit(localValue);
+		const onPointerDown = (event) => {
+			const wrapper = wrapperRef.current;
+			if (!wrapper) return;
+			const target = event.target;
+			if (target && wrapper.contains(target)) return;
+			if (isInsidePortal(event.target)) return;
+			commitRef.current();
 		};
-		document.addEventListener("mousedown", handleClickOutside);
-		return () => document.removeEventListener("mousedown", handleClickOutside);
-	}, [onCommit, localValue]);
+		document.addEventListener("pointerdown", onPointerDown);
+		return () => document.removeEventListener("pointerdown", onPointerDown);
+	}, []);
 	const handleKeyDown = useCallback((e) => {
 		if (e.key === "Enter" && !e.shiftKey) {
 			e.preventDefault();
@@ -48,7 +54,7 @@ function SpreadsheetCellEditor({ cellType, value, enumOptions, onCommit, onCance
 		onCommit,
 		onCancel
 	]);
-	return /* @__PURE__ */ jsx(EditorWrapper, {
+	return /* @__PURE__ */ jsx(CellEditorWrapper, {
 		ref: wrapperRef,
 		children: match(cellType).with(SpreadsheetCellType.TEXT, () => /* @__PURE__ */ jsx(TextInput, {
 			value: String(localValue ?? ""),

package/dist/table/SpreadsheetHeaderCell.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { TableDensity, TableVariant, type SpreadsheetColumnDef, type SpreadsheetRowsContext } from "./types";
+export interface SpreadsheetHeaderCellProps<TData> {
+    column: SpreadsheetColumnDef<TData, unknown>;
+    columnIndex: number;
+    width?: number;
+    pinnedOffset?: number;
+    density: TableDensity;
+    variant: TableVariant;
+    rowsContext: SpreadsheetRowsContext<TData>;
+    isResizable: boolean;
+    isResizing: boolean;
+    resizeBounds: {
+        min: number;
+        max: number;
+        current: number | undefined;
+    };
+    onResizeStart: (columnId: string, clientX: number, measuredWidth?: number) => void;
+    onResizeKeyDown: (columnId: string, event: React.KeyboardEvent) => void;
+}
+declare function SpreadsheetHeaderCellInner<TData>({ column, columnIndex, width, pinnedOffset, density, variant, rowsContext, isResizable, isResizing, resizeBounds, onResizeStart, onResizeKeyDown, }: SpreadsheetHeaderCellProps<TData>): React.JSX.Element;
+declare const SpreadsheetHeaderCell: typeof SpreadsheetHeaderCellInner;
+export default SpreadsheetHeaderCell;

package/dist/table/SpreadsheetHeaderCell.js

@@ -0,0 +1,91 @@
+import Icon, { IconVariant } from "../icons/Icon.js";
+import FlexWrapper, { FlexDirection } from "../containers/FlexWrapper.js";
+import { TableHeaderCell } from "./TablePrimitives.js";
+import TableHeaderCellContent from "./TableHeaderCellContent.js";
+import Dropdown, { DropdownPosition } from "../dropdown/Dropdown.js";
+import SpreadsheetMenuItem from "./SpreadsheetMenuItem.js";
+import { HeaderMenuTrigger } from "./SpreadsheetPrimitives.js";
+import React, { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { DotsThreeVerticalIcon } from "@phosphor-icons/react";
+//#region src/table/SpreadsheetHeaderCell.tsx
+function SpreadsheetHeaderCellInner({ column, columnIndex, width, pinnedOffset, density, variant, rowsContext, isResizable, isResizing, resizeBounds, onResizeStart, onResizeKeyDown }) {
+	const [isMenuOpen, setIsMenuOpen] = useState(false);
+	const headerActions = column.headerActions ?? [];
+	const enrichmentActions = column.enrichmentActions ?? [];
+	const hasMenu = headerActions.length > 0 || enrichmentActions.length > 0;
+	const label = column.header ?? column.id;
+	const menu = hasMenu ? /* @__PURE__ */ jsx(Dropdown, {
+		body: /* @__PURE__ */ jsxs(FlexWrapper, {
+			direction: FlexDirection.COLUMN,
+			gap: 2,
+			children: [enrichmentActions.map((action) => /* @__PURE__ */ jsx(SpreadsheetMenuItem, {
+				icon: action.icon,
+				label: action.label,
+				onClick: () => {
+					action.onAction(column.id, rowsContext);
+					setIsMenuOpen(false);
+				}
+			}, `enrich-${action.id}`)), headerActions.map((action) => /* @__PURE__ */ jsx(SpreadsheetMenuItem, {
+				icon: action.icon,
+				label: action.label,
+				variant: action.variant,
+				onClick: () => {
+					action.onAction(column.id);
+					setIsMenuOpen(false);
+				}
+			}, `action-${action.id}`))]
+		}),
+		position: DropdownPosition.BOTTOM_END,
+		offset: [0, 4],
+		isOpen: isMenuOpen,
+		onClose: () => setIsMenuOpen(false),
+		minWidth: 160,
+		children: /* @__PURE__ */ jsx(HeaderMenuTrigger, {
+			type: "button",
+			"aria-label": `${label} column options`,
+			"aria-expanded": isMenuOpen,
+			"aria-haspopup": true,
+			onClick: (event) => {
+				event.stopPropagation();
+				setIsMenuOpen(!isMenuOpen);
+			},
+			children: /* @__PURE__ */ jsx(Icon, {
+				component: DotsThreeVerticalIcon,
+				size: 12,
+				variant: IconVariant.TERTIARY
+			})
+		})
+	}) : void 0;
+	return /* @__PURE__ */ jsx(TableHeaderCell, {
+		$width: width,
+		$minWidth: column.minSize,
+		$maxWidth: column.maxSize,
+		$pin: column.pin,
+		$pinnedOffset: pinnedOffset,
+		$align: column.align,
+		$density: density,
+		$variant: variant,
+		role: "columnheader",
+		scope: "col",
+		"aria-colindex": columnIndex + 1,
+		"aria-label": column.headerAriaLabel,
+		children: /* @__PURE__ */ jsx(TableHeaderCellContent, {
+			content: label,
+			isSortable: false,
+			sortDirection: false,
+			trailing: menu,
+			resize: isResizable ? {
+				columnId: column.id,
+				columnLabel: label,
+				isResizing,
+				bounds: resizeBounds,
+				onResizeStart,
+				onResizeKeyDown
+			} : void 0
+		})
+	});
+}
+var SpreadsheetHeaderCell = React.memo(SpreadsheetHeaderCellInner);
+//#endregion
+export { SpreadsheetHeaderCell as default };

package/dist/table/SpreadsheetMenuItem.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+import { TextVariant } from "../text/Text";
+export interface SpreadsheetMenuItemProps {
+    icon?: ReactNode;
+    label: string;
+    variant?: TextVariant;
+    onClick: () => void;
+}
+/**
+ * One row of a spreadsheet dropdown — shared by the column header menu and the
+ * row action menu, which previously carried byte-identical copies.
+ */
+declare const SpreadsheetMenuItem: ({ icon, label, variant, onClick }: SpreadsheetMenuItemProps) => import("react").JSX.Element;
+export default SpreadsheetMenuItem;

package/dist/table/SpreadsheetMenuItem.js

@@ -0,0 +1,33 @@
+import { withTheme } from "../theme/GalaxyTheme.js";
+import Text, { TextSize, TextWeight } from "../text/Text.js";
+/* empty css                              */
+import { styled } from "@linaria/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/table/SpreadsheetMenuItem.tsx
+var _exp = () => ({ theme }) => theme.color.background.secondary;
+var _exp2 = () => ({ theme }) => theme.color.border.selected;
+var MenuItemButton = withTheme(/*#__PURE__*/ styled("button")({
+	name: "MenuItemButton",
+	class: "m16ywplt",
+	propsAsIs: false,
+	vars: {
+		"m16ywplt-0": [_exp()],
+		"m16ywplt-1": [_exp2()]
+	}
+}));
+/**
+* One row of a spreadsheet dropdown — shared by the column header menu and the
+* row action menu, which previously carried byte-identical copies.
+*/
+var SpreadsheetMenuItem = ({ icon, label, variant, onClick }) => /* @__PURE__ */ jsxs(MenuItemButton, {
+	type: "button",
+	onClick,
+	children: [icon, /* @__PURE__ */ jsx(Text, {
+		size: TextSize.BODY_SM,
+		weight: TextWeight.MEDIUM,
+		variant,
+		children: label
+	})]
+});
+//#endregion
+export { SpreadsheetMenuItem as default };

package/dist/table/SpreadsheetPrimitives.d.ts

@@ -0,0 +1,172 @@
+import { CellEnrichmentStatus, TableVariant } from "./types";
+/**
+ * Styled leaves with no equivalent in `TablePrimitives` — the trailing action
+ * column, the enrichment status dot, and the inline editor overlay.
+ *
+ * Everything here is non-generic: `withTheme` erases type parameters, so the
+ * generic row/cell components compose these rather than being wrapped.
+ */
+/** Trailing sticky header cell holding the add-column control. */
+export declare const ActionColumnHeaderCell: import("react").ComponentType<Pick<import("react").ClassAttributes<HTMLTableHeaderCellElement> & import("react").ThHTMLAttributes<HTMLTableHeaderCellElement> & {
+    $variant?: TableVariant;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}, "as" | "$variant" | keyof import("react").ClassAttributes<HTMLTableHeaderCellElement> | keyof import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<import("../theme").Theme> | undefined;
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<import("react").ComponentType<import("react").ClassAttributes<HTMLTableHeaderCellElement> & import("react").ThHTMLAttributes<HTMLTableHeaderCellElement> & {
+    $variant?: TableVariant;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}> & {
+    __wyw_meta: unknown;
+} & import("react").FunctionComponent<import("react").ClassAttributes<HTMLTableHeaderCellElement> & import("react").ThHTMLAttributes<HTMLTableHeaderCellElement> & {
+    $variant?: TableVariant;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}>, {}>;
+/** Trailing sticky body cell holding the row action menu. */
+export declare const ActionColumnCell: import("react").ComponentType<Pick<import("react").ClassAttributes<HTMLTableDataCellElement> & import("react").TdHTMLAttributes<HTMLTableDataCellElement> & {
+    $variant?: TableVariant;
+    $pinnedOffset?: number;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}, "as" | "$variant" | "$pinnedOffset" | keyof import("react").ClassAttributes<HTMLTableDataCellElement> | keyof import("react").TdHTMLAttributes<HTMLTableDataCellElement>> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<import("../theme").Theme> | undefined;
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<import("react").ComponentType<import("react").ClassAttributes<HTMLTableDataCellElement> & import("react").TdHTMLAttributes<HTMLTableDataCellElement> & {
+    $variant?: TableVariant;
+    $pinnedOffset?: number;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}> & {
+    __wyw_meta: unknown;
+} & import("react").FunctionComponent<import("react").ClassAttributes<HTMLTableDataCellElement> & import("react").TdHTMLAttributes<HTMLTableDataCellElement> & {
+    $variant?: TableVariant;
+    $pinnedOffset?: number;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}>, {}>;
+/** Keeps the trailing column's width when a row has no actions. */
+export declare const ActionColumnSpacerCell: import("react").ComponentType<Pick<import("react").ClassAttributes<HTMLTableDataCellElement> & import("react").TdHTMLAttributes<HTMLTableDataCellElement> & {
+    $variant?: TableVariant;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}, "as" | "$variant" | keyof import("react").ClassAttributes<HTMLTableDataCellElement> | keyof import("react").TdHTMLAttributes<HTMLTableDataCellElement>> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<import("../theme").Theme> | undefined;
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<import("react").ComponentType<import("react").ClassAttributes<HTMLTableDataCellElement> & import("react").TdHTMLAttributes<HTMLTableDataCellElement> & {
+    $variant?: TableVariant;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}> & {
+    __wyw_meta: unknown;
+} & import("react").FunctionComponent<import("react").ClassAttributes<HTMLTableDataCellElement> & import("react").TdHTMLAttributes<HTMLTableDataCellElement> & {
+    $variant?: TableVariant;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}>, {}>;
+/**
+ * Column header menu trigger.
+ *
+ * Deliberately chrome-less rather than a `Button`: it should read as a peer of
+ * the table's sort caret — a bare 12px tertiary icon — not as a control sitting
+ * in the header. It stays a real `button` so it remains focusable and announced.
+ */
+export declare const HeaderMenuTrigger: import("react").ComponentType<Pick<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}, "as" | keyof import("react").ClassAttributes<HTMLButtonElement> | keyof import("react").ButtonHTMLAttributes<HTMLButtonElement>> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<import("../theme").Theme> | undefined;
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<import("react").ComponentType<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}> & {
+    __wyw_meta: unknown;
+} & import("react").FunctionComponent<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}>, {}>;
+export declare const CellStatusDot: import("react").ComponentType<Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    $status: CellEnrichmentStatus;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}, keyof import("react").ClassAttributes<HTMLDivElement> | keyof import("react").HTMLAttributes<HTMLDivElement> | "as" | "$status"> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<import("../theme").Theme> | undefined;
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<import("react").ComponentType<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    $status: CellEnrichmentStatus;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}> & {
+    __wyw_meta: unknown;
+} & import("react").FunctionComponent<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    $status: CellEnrichmentStatus;
+} & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}>, {}>;
+/**
+ * Inline editor overlay.
+ *
+ * `inset: 0` resolves against the cell only because the cell is rendered with
+ * `$isPositioned` — otherwise the nearest positioned ancestor is the row, which
+ * is `position: absolute` in a virtualized body.
+ */
+export declare const CellEditorWrapper: import("react").ComponentType<Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}, keyof import("react").ClassAttributes<HTMLDivElement> | keyof import("react").HTMLAttributes<HTMLDivElement> | "as"> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<import("../theme").Theme> | undefined;
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<import("react").ComponentType<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}> & {
+    __wyw_meta: unknown;
+} & import("react").FunctionComponent<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}>, {}>;
+/** Skeleton block shown in a loading cell. */
+export declare const CellLoadingSkeleton: import("react").ComponentType<Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}, keyof import("react").ClassAttributes<HTMLDivElement> | keyof import("react").HTMLAttributes<HTMLDivElement> | "as"> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<import("../theme").Theme> | undefined;
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<import("react").ComponentType<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}> & {
+    __wyw_meta: unknown;
+} & import("react").FunctionComponent<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    theme: import("../theme").Theme;
+} & {
+    as?: React.ElementType;
+}>, {}>;

package/dist/table/SpreadsheetPrimitives.js

@@ -0,0 +1,105 @@
+import { withTheme } from "../theme/GalaxyTheme.js";
+import { CellEnrichmentStatus } from "./types.js";
+import { getVariantBackgroundColor } from "./utils.js";
+/* empty css                                */
+import { styled } from "@linaria/react";
+import { match } from "ts-pattern";
+//#region src/table/SpreadsheetPrimitives.tsx
+/**
+* Styled leaves with no equivalent in `TablePrimitives` — the trailing action
+* column, the enrichment status dot, and the inline editor overlay.
+*
+* Everything here is non-generic: `withTheme` erases type parameters, so the
+* generic row/cell components compose these rather than being wrapped.
+*/
+/** Trailing sticky header cell holding the add-column control. */
+var _exp2 = () => ({ $variant, theme }) => getVariantBackgroundColor(theme, $variant);
+var _exp4 = () => ({ theme }) => theme.color.border.primary;
+var ActionColumnHeaderCell = withTheme(/*#__PURE__*/ styled("th")({
+	name: "ActionColumnHeaderCell",
+	class: "a1wb3h41",
+	propsAsIs: false,
+	vars: {
+		"a1wb3h41-0": [_exp2()],
+		"a1wb3h41-1": [_exp4()]
+	}
+}));
+/** Trailing sticky body cell holding the row action menu. */
+var _exp5 = () => ({ $pinnedOffset }) => $pinnedOffset !== void 0 ? `${$pinnedOffset}px` : "0";
+var _exp7 = () => ({ $variant, theme }) => getVariantBackgroundColor(theme, $variant);
+var _exp8 = () => ({ theme }) => theme.color.border.primary;
+var ActionColumnCell = withTheme(/*#__PURE__*/ styled("td")({
+	name: "ActionColumnCell",
+	class: "an0h7xt",
+	propsAsIs: false,
+	vars: {
+		"an0h7xt-0": [_exp5()],
+		"an0h7xt-1": [_exp7()],
+		"an0h7xt-2": [_exp8()]
+	}
+}));
+/** Keeps the trailing column's width when a row has no actions. */
+var _exp0 = () => ({ $variant, theme }) => getVariantBackgroundColor(theme, $variant);
+var _exp1 = () => ({ theme }) => theme.color.border.primary;
+var ActionColumnSpacerCell = withTheme(/*#__PURE__*/ styled("td")({
+	name: "ActionColumnSpacerCell",
+	class: "asyqbtk",
+	propsAsIs: false,
+	vars: {
+		"asyqbtk-0": [_exp0()],
+		"asyqbtk-1": [_exp1()]
+	}
+}));
+/**
+* Column header menu trigger.
+*
+* Deliberately chrome-less rather than a `Button`: it should read as a peer of
+* the table's sort caret — a bare 12px tertiary icon — not as a control sitting
+* in the header. It stays a real `button` so it remains focusable and announced.
+*/
+var _exp10 = () => ({ theme }) => theme.color.border.selected;
+var HeaderMenuTrigger = withTheme(/*#__PURE__*/ styled("button")({
+	name: "HeaderMenuTrigger",
+	class: "hykjqu1",
+	propsAsIs: false,
+	vars: { "hykjqu1-0": [_exp10()] }
+}));
+var _exp13 = () => ({ $status, theme }) => match($status).with(CellEnrichmentStatus.PENDING, () => theme.color.text.tertiary).with(CellEnrichmentStatus.RUNNING, () => theme.color.background.galaxy).with(CellEnrichmentStatus.COMPLETE, () => theme.color.icon.success).with(CellEnrichmentStatus.ERROR, () => theme.color.text.error).otherwise(() => "transparent");
+var _exp14 = () => ({ $status }) => $status === CellEnrichmentStatus.RUNNING ? "enrichPulse 1.2s ease-in-out infinite" : "none";
+var CellStatusDot = withTheme(/*#__PURE__*/ styled("div")({
+	name: "CellStatusDot",
+	class: "c1yt5ynl",
+	propsAsIs: false,
+	vars: {
+		"c1yt5ynl-0": [_exp13()],
+		"c1yt5ynl-1": [_exp14()]
+	}
+}));
+/**
+* Inline editor overlay.
+*
+* `inset: 0` resolves against the cell only because the cell is rendered with
+* `$isPositioned` — otherwise the nearest positioned ancestor is the row, which
+* is `position: absolute` in a virtualized body.
+*/
+var _exp15 = () => ({ theme }) => theme.color.background.primary;
+var _exp16 = () => ({ theme }) => theme.color.border.galaxy;
+var CellEditorWrapper = withTheme(/*#__PURE__*/ styled("div")({
+	name: "CellEditorWrapper",
+	class: "c1kvxq2r",
+	propsAsIs: false,
+	vars: {
+		"c1kvxq2r-0": [_exp15()],
+		"c1kvxq2r-1": [_exp16()]
+	}
+}));
+/** Skeleton block shown in a loading cell. */
+var _exp17 = () => ({ theme }) => theme.color.background.tertiary;
+var CellLoadingSkeleton = withTheme(/*#__PURE__*/ styled("div")({
+	name: "CellLoadingSkeleton",
+	class: "cz6gl36",
+	propsAsIs: false,
+	vars: { "cz6gl36-0": [_exp17()] }
+}));
+//#endregion
+export { ActionColumnCell, ActionColumnHeaderCell, ActionColumnSpacerCell, CellEditorWrapper, CellLoadingSkeleton, CellStatusDot, HeaderMenuTrigger };

package/dist/table/SpreadsheetRow.d.ts

@@ -0,0 +1,33 @@
+import React from "react";
+import { TableDensity, TableVariant, type EditingCell, type SpreadsheetColumnDef, type SpreadsheetRowAction } from "./types";
+export interface SpreadsheetRowProps<TData> {
+    rowData: TData | undefined;
+    rowIndex: number;
+    translateY: number;
+    rowHeight: number;
+    isLastRow: boolean;
+    density: TableDensity;
+    variant: TableVariant;
+    columns: SpreadsheetColumnDef<TData, unknown>[];
+    pinnedOffsets: Map<string, number>;
+    getColumnWidth: (col: SpreadsheetColumnDef<TData, unknown>) => number | undefined;
+    editingCell: EditingCell | null;
+    onStartEditing: (rowIndex: number, columnId: string) => void;
+    onCommitEditing: () => void;
+    onCancelEditing: () => void;
+    rowActions?: SpreadsheetRowAction<TData>[];
+    rowActionsAriaLabel?: string;
+    showActionColumn?: boolean;
+    tabIndex?: number;
+    onFocus?: () => void;
+    onKeyDown?: (event: React.KeyboardEvent) => void;
+}
+declare function SpreadsheetRowInner<TData>({ rowData, rowIndex, translateY, rowHeight, isLastRow, density, variant, columns, pinnedOffsets, getColumnWidth, editingCell, onStartEditing, onCommitEditing, onCancelEditing, rowActions, rowActionsAriaLabel, showActionColumn, tabIndex, onFocus, onKeyDown, }: SpreadsheetRowProps<TData>): React.JSX.Element;
+/**
+ * Default shallow comparison: `columns`, `getColumnWidth` and `pinnedOffsets`
+ * are all memoized upstream, so every prop that affects the output takes part.
+ * A hand-written comparator here previously dropped `rowHeight`, which left
+ * mounted rows at a stale height whenever density changed.
+ */
+declare const SpreadsheetRow: typeof SpreadsheetRowInner;
+export default SpreadsheetRow;