@servicetitan/anvil2 3.14.1 → 3.15.1

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableCellEditIcon.d.ts

@@ -1,5 +1,2 @@
-/**
- * Edit icon for editable cells in data tables
- * @returns The edit icon
- */
+/** Decorative edit affordance; not a separate control. */
 export declare const DataTableEditableCellEditIcon: () => import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableCustomCell.d.ts

@@ -1,5 +1,9 @@
 import { BaseEditableCellProps, EditableCellImperativeHandle } from './types';
 type DataTableEditableCustomCellProps<T> = BaseEditableCellProps<T>;
+/**
+ * Editable grid cell that hosts a consumer-rendered object editor in a
+ * coordinated surface.
+ */
 export declare const DataTableEditableCustomCell: (<T>(props: DataTableEditableCustomCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableMultiselectAsyncCell.d.ts

@@ -1,32 +1,12 @@
 import { EditableCellImperativeHandle, BaseEditableCellProps } from './types';
 export type DataTableEditableMultiselectAsyncCellProps<T> = BaseEditableCellProps<T>;
+export declare function DataTableEditableMultiselectAsyncCellInner<T>(props: DataTableEditableMultiselectAsyncCellProps<T>, ref: React.Ref<EditableCellImperativeHandle>): import("react/jsx-runtime").JSX.Element;
 /**
- * Renders an async editable multiselect cell in a DataTable. This component provides a
- * MultiSelectMenu popover that loads options asynchronously via a `loadOptions` function.
- * The loader receives a `context` object containing the current row data, enabling per-row
- * option loading.
- *
- * Features:
- * - Supports all four MultiSelectMenu lazy variants: eager, page, offset, and group
- * - Passes row context to `loadOptions` for per-row async option loading
- * - Auto-disables caching by default to prevent cross-row cache pollution
- * - Supports full MultiSelectMenu passthrough props (debounceMs, virtualize, selectAll, etc.)
- * - Live selection: `onChange` fires on each toggle
- * - Keyboard navigation consistent with other editable cell types
- *
- * **Value contract**: Unlike `mode: "multiselect"` (which stores ID arrays), the cell value
- * must be `MultiSelectMenuOption[]` — full option objects. The consumer stores them wholesale
- * from the `onChange` callback.
- *
- * @param props - The props for the DataTableEditableMultiselectAsyncCell component
- * @param props.cell - The TanStack table cell instance
- * @param props.cellProps - Props for styling and event handling of the cell container
- * @param props.cellPosition - The position of the cell in the table
- * @param props.children - The content to display when not editing
- * @param ref - Ref to the imperative handle for programmatic control
- * @returns The rendered async editable multiselect cell component
+ * Async multi-select menu editor. Cell value is `MultiSelectMenuOption[]`, not
+ * ids. `loadOptions` receives `{ row, rowId }` as `context`; cache defaults to
+ * disabled. Missing `editConfig` or a non-array, non-nullish value falls back
+ * to a read-only body cell.
  */
-export declare function DataTableEditableMultiselectAsyncCellInner<T>(props: DataTableEditableMultiselectAsyncCellProps<T>, ref: React.Ref<EditableCellImperativeHandle>): import("react/jsx-runtime").JSX.Element;
 export declare const DataTableEditableMultiselectAsyncCell: (<T>(props: DataTableEditableMultiselectAsyncCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableMultiselectCell.d.ts

@@ -1,20 +1,10 @@
 import { EditableCellImperativeHandle, BaseEditableCellProps } from './types';
 export type DataTableEditableMultiselectCellProps<T> = BaseEditableCellProps<T>;
+export declare function DataTableEditableMultiselectCellInner<T>(props: DataTableEditableMultiselectCellProps<T>, ref: React.Ref<EditableCellImperativeHandle>): import("react/jsx-runtime").JSX.Element;
 /**
- * Renders an editable multiselect cell in a DataTable. This component provides a
- * MultiSelectMenu popover with search that appears when the cell is activated, allowing
- * users to select multiple values from a list of options. Supports keyboard navigation
- * and live selection.
- *
- * @param props - The props for the DataTableEditableMultiselectCell component
- * @param props.cell - The TanStack table cell instance
- * @param props.cellProps - Props for styling and event handling of the cell container
- * @param props.cellPosition - The position of the cell in the table
- * @param props.children - The content to display when not editing
- * @param ref - Ref to the imperative handle for programmatic control
- * @returns The rendered editable multiselect cell component
+ * Sync multi-select menu editor. Cell value is an id array. Non-array values
+ * (except nullish) or missing `editConfig` fall back to a read-only body cell.
  */
-export declare function DataTableEditableMultiselectCellInner<T>(props: DataTableEditableMultiselectCellProps<T>, ref: React.Ref<EditableCellImperativeHandle>): import("react/jsx-runtime").JSX.Element;
 export declare const DataTableEditableMultiselectCell: (<T>(props: DataTableEditableMultiselectCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableNumberCell.d.ts

@@ -1,5 +1,9 @@
 import { EditableCellImperativeHandle, BaseEditableCellProps } from './types';
 export type DataTableEditableNumberCellProps<T> = BaseEditableCellProps<T>;
+/**
+ * Inline number editor. Enter/F2 and blur commit; Escape restores the committed
+ * value. Opening reseeds the draft from the cell.
+ */
 export declare const DataTableEditableNumberCell: (<T>(props: DataTableEditableNumberCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableSelectAsyncCell.d.ts

@@ -1,5 +1,10 @@
 import { EditableCellImperativeHandle, BaseEditableCellProps } from './types';
 export type DataTableEditableSelectAsyncCellProps<T> = BaseEditableCellProps<T>;
+/**
+ * Async single-select menu editor. `loadOptions` receives `{ row, rowId }` as
+ * `context`. Cache defaults to disabled so rows do not share option results.
+ * Arrays or missing `editConfig` fall back to a read-only body cell.
+ */
 export declare const DataTableEditableSelectAsyncCell: (<T>(props: DataTableEditableSelectAsyncCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableSelectCell.d.ts

@@ -1,5 +1,9 @@
 import { EditableCellImperativeHandle, BaseEditableCellProps } from './types';
 export type DataTableEditableSelectCellProps<T> = BaseEditableCellProps<T>;
+/**
+ * Sync single-select menu editor. Arrays or missing `editConfig` fall back to a
+ * read-only body cell.
+ */
 export declare const DataTableEditableSelectCell: (<T>(props: DataTableEditableSelectCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableTextCell.d.ts

@@ -1,5 +1,9 @@
 import { EditableCellImperativeHandle, BaseEditableCellProps } from './types';
 export type DataTableEditableTextCellProps<T> = BaseEditableCellProps<T>;
+/**
+ * Inline text editor. Enter/F2 and blur commit; Escape restores the committed
+ * value. Invalid cell types fall back to a read-only body cell.
+ */
 export declare const DataTableEditableTextCell: (<T>(props: DataTableEditableTextCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/types.d.ts

@@ -2,37 +2,24 @@ import { DataTableBodyCellProps } from '../../../base/cells/TableBodyCell';
 import { CellPosition } from '../../../internal/types';
 import { Cell } from '@tanstack/react-table';
 /**
- * Imperative handle for editable cell components, allowing programmatic control
- * of editing state and focus management
+ * Parent-facing handle. `invoke` starts or toggles the editor; `focus`
+ * DOM-focuses the cell and sets its tabIndex to 0.
  */
 export type EditableCellImperativeHandle = {
     invoke: () => void;
     focus: () => void;
 };
 /**
- * Props passed to editable cells for styling and event handling
- * This is a subset of DataTableBodyCellProps containing only the properties
- * that are actually used by editable cell components
+ * Container props the mutable body cell forwards onto the editor host.
  */
 export type EditableCellCellProps = Pick<DataTableBodyCellProps, "className" | "onKeyDown" | "style">;
-/**
- * Base props shared by all editable cell components
- */
 export type BaseEditableCellProps<T> = {
-    /**
-     * The TanStack table cell instance
-     */
+    /** Supplies row and column state for the editor and commit path. */
     cell: Cell<T, unknown>;
-    /**
-     * Props for styling and event handling of the cell container
-     */
+    /** Host styles and grid key handling applied to the cell container. */
     cellProps: EditableCellCellProps;
-    /**
-     * The position of the cell in the table
-     */
+    /** Coordinates used by the grid's roving-focus manager. */
     cellPosition: CellPosition;
-    /**
-     * The children to render in the cell
-     */
+    /** Formatted value. Inline editors replace it while open; overlay editors keep it visible. */
     children: React.ReactNode;
 };

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/useCustomEditHelpers.d.ts

@@ -3,49 +3,36 @@ type CustomObjectValue = object;
 type CustomEditHelperValue<T, K extends keyof T> = CustomEditDraftValue<T, K>;
 type CustomEditHelperPresentValue<T, K extends keyof T> = CustomEditPresentObjectValue<T, K>;
 type CustomEditHelperInitialValue<T, K extends keyof T> = CustomEditInitialValue<T, K>;
-/**
- * State returned by custom edit controller helpers.
- * @property {CustomEditController<TValue>} controller - Controller object exposed to custom edit renderers.
- * @property {() => void} runInitialFocus - Runs the initial focus callback registered by the custom editor.
- */
 export type CustomEditControllerState<TValue extends CustomObjectValue, TDraftValue = Partial<TValue>, TInitialValue = TValue> = {
+    /** Draft, dirty, validation, and close APIs for the custom renderer. */
     controller: CustomEditController<TValue, TDraftValue, TInitialValue>;
+    /** Invokes the callback last registered with `setInitialFocus`. */
     runInitialFocus: () => void;
 };
-/**
- * Options for creating custom edit controller state.
- * @property {TableRow<T>} row - Row whose cell value is being edited.
- * @property {K} columnId - Column id for the editable cell.
- * @property {CustomEditConfig<T, K>} editConfig - Custom edit configuration for the column.
- * @property {() => void} [onCloseEditor] - Called after the editor closes successfully.
- */
 export type UseCustomEditControllerStateOptions<T, K extends keyof T> = {
+    /** Row whose column value seeds the draft. */
     row: TableRow<T>;
+    /** Field on the row being edited. */
     columnId: K;
+    /** Validate, commit, and request-close callbacks for this column. */
     editConfig: CustomEditConfig<T, K>;
+    /** After a close that was not blocked by validation or `onRequestClose`. */
     onCloseEditor?: () => void;
 };
 export type UseCustomEditHelperStateOptions<T, K extends keyof T> = UseCustomEditControllerStateOptions<T, K>;
 /**
- * Creates React stateful helpers for a custom editable DataTable cell.
- *
- * @param options Row, column, edit configuration, and close callback for the editable cell.
- * @returns Controller state with draft value helpers and initial focus runner.
+ * React custom-edit controller. Escape discards; other `requestClose` reasons
+ * submit. `blockOnValidationError` blocks submit only; `onRequestClose`
+ * returning `false` blocks submit and discard.
  */
 export declare function useCustomEditControllerState<T, K extends keyof T>({ row, columnId, editConfig, onCloseEditor, }: UseCustomEditControllerStateOptions<T, K>): CustomEditControllerState<CustomEditHelperPresentValue<T, K>, CustomEditHelperValue<T, K>, CustomEditHelperInitialValue<T, K>>;
-/**
- * Backward-compatible alias for the custom edit controller hook.
- */
+/** Alias of {@link useCustomEditControllerState}. */
 export declare const useCustomEditHelperState: typeof useCustomEditControllerState;
 /**
- * Creates imperative custom edit helpers for non-React consumers and tests.
- *
- * @param options Row, column, edit configuration, and close callback for the editable cell.
- * @returns Controller state with mutable draft value helpers and initial focus runner.
+ * Imperative twin of {@link useCustomEditControllerState} for tests and
+ * non-React callers. Same Escape/submit/discard and validation-block contract.
  */
 export declare function createCustomEditControllerState<T, K extends keyof T>({ row, columnId, editConfig, onCloseEditor, }: UseCustomEditControllerStateOptions<T, K>): CustomEditControllerState<CustomEditHelperPresentValue<T, K>, CustomEditHelperValue<T, K>, CustomEditHelperInitialValue<T, K>>;
-/**
- * Backward-compatible alias for the imperative custom edit controller factory.
- */
+/** Alias of {@link createCustomEditControllerState}. */
 export declare const createCustomEditHelperState: typeof createCustomEditControllerState;
 export {};

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/useEditableMenuCell.d.ts

@@ -6,16 +6,8 @@ type UseEditableMenuCellOptions = {
     ref: React.Ref<EditableCellImperativeHandle>;
 };
 /**
- * Shared hook for select/multiselect editable DataTable cells that use a menu-based
- * editing UX (SelectMenu, MultiSelectMenu, and their async variants).
- *
- * Encapsulates the common state, refs, imperative handle, and keyboard/focus/mouse handlers
- * that are identical across all four menu-based cell components.
- *
- * @param options.cellPosition - The position of the cell in the table grid
- * @param options.onCellKeyDown - The cell's keyDown handler from cellProps, forwarded when the menu is closed
- * @param options.ref - Ref for the imperative handle (invoke/focus)
- * @returns Shared state, refs, and event handlers
+ * Shared open/close and focus wiring for menu-based editable cells. While the
+ * menu is closed, keys stay on the grid; while open they go to the menu.
  */
 export declare function useEditableMenuCell({ cellPosition, onCellKeyDown, ref, }: UseEditableMenuCellOptions): {
     tabIndex: number;

package/dist/src/beta/components/Table/DataTable/internal/useAsyncData.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Resolves a value-or-promise into `{ data, error, isLoading }`.
+ *
+ * A non-Promise argument is returned from the same render with `isLoading:
+ * false`, so array identity is preserved. Promise results come from state
+ * (initially `{ data: null, isLoading: true }`); a newer argument identity
+ * bumps a request id so an older in-flight Promise cannot write back.
+ */
 export declare const useAsyncData: <T>(dataOrPromise: T | Promise<T>) => {
     data: T | null;
     error: boolean;

package/dist/src/beta/components/Table/DataTable/internal/useColumnOrder.d.ts

@@ -1,7 +1,7 @@
 import { Table as TanstackTable } from '@tanstack/react-table';
 /**
- * Hook to analyze the columns in the table to determine the visual position and pinning status
- * @param table - The table to analyze
+ * Visual leaf-column order: pinned left, unpinned, then pinned right.
+ * `columnIndexMap` maps each leaf `getIndex()` to that visual position.
  */
 export declare const useColumnOrder: <T>({ table }: {
     table: TanstackTable<T>;

package/dist/src/beta/components/Table/DataTable/internal/useDataTableVirtualizer.d.ts

@@ -1,29 +1,18 @@
 import { RefObject } from 'react';
 import { Virtualizer } from '@tanstack/react-virtual';
 /**
- * Row count threshold at which row virtualization activates. Tables with fewer
- * than this many rows render all rows in the DOM (the pre-virtualization
- * behavior); tables with this many or more are virtualized.
- *
- * Set to 50 so tables with 49 or fewer rows remain non-virtualized (and
- * therefore keep every row — including any editable cells — fully mounted).
+ * Minimum body row count that turns virtualization on. Fewer rows stay fully
+ * mounted, including editable cells.
  */
 export declare const VIRTUALIZATION_THRESHOLD = 50;
 export type DataTableVirtualizer = Virtualizer<HTMLDivElement, HTMLDivElement>;
 /**
- * Create a TanStack virtualizer for DataTable body rows.
- *
- * Returns `undefined` when virtualization is disabled or when `rowCount` is
- * below `VIRTUALIZATION_THRESHOLD` (and `forced` is not `true`), signaling to
- * the body that rows should render via the non-virtualized flat flow.
- *
- * When both `disabled` and `forced` are `true`, `disabled` wins.
+ * TanStack row virtualizer for the DataTable body, or `undefined` so the body
+ * can flat-render.
  *
- * @param rowCount Total number of body rows that would render if not virtualized.
- * @param scrollRef Ref to the scrollable container whose scroll position the virtualizer tracks.
- * @param disabled When `true`, virtualization is skipped regardless of row count.
- * @param forced When `true`, virtualization runs regardless of row count (subject to `disabled`).
- * @returns A `Virtualizer` instance when virtualization should run; `undefined` when the body should flat-render.
+ * Virtualizes when `rowCount` is at least {@link VIRTUALIZATION_THRESHOLD},
+ * unless `disabled`. `forced` virtualizes below the threshold; `disabled` wins
+ * if both are set.
  */
 export declare function useDataTableVirtualizer({ rowCount, scrollRef, disabled, forced, }: {
     rowCount: number;

package/dist/src/beta/components/Table/DataTable/internal/usePageDataCache.d.ts

@@ -1,16 +1,12 @@
 import { TableRow } from '../../types';
 import { DataTableCacheOptions, SortedColumn } from '../types';
 /**
- * Hook for caching resolved page data in DataTable.
- *
- * Features:
- * - Caches resolved page data per page index using a Map stored in a ref
- * - Returns cached data synchronously on cache hit, avoiding unnecessary API calls
- * - Synchronously clears cache during render when invalidation triggers change
- * - Size-based eviction (FIFO) when cache exceeds maxSize: oldest entry is dropped to make room
- *
- * @param config - Configuration including loadPageData function, cache options, and invalidation triggers
- * @returns Object containing getOrLoad function and clearCache function
+ * Caches `loadPageData` rows by page index. Hits return synchronously; misses
+ * call the loader. `refreshKey`, `refreshCounter`, `rowsPerPage`, and sort
+ * `id`/`desc` replace the Map during render so a later `getOrLoad` cannot
+ * read a stale page. In-flight resolves after a generation bump still fulfill
+ * the caller but are not written into the Map. Caching is on by default with
+ * a 15-entry FIFO cap; with no loader, `getOrLoad` returns `[]`.
  */
 export declare function usePageDataCache<T>(config: {
     loadPageData?: (params: {

package/dist/src/beta/components/Table/DataTable/internal/util/cellPositionHelpers.d.ts

@@ -1,6 +1,3 @@
 import { CellPosition } from '../../../internal/types';
 export declare function formatCellPositionString(cellPosition: CellPosition): string;
-/**
- * Checks if two cell positions are equal.
- */
 export declare function areCellPositionsEqual(pos1: CellPosition | null | undefined, pos2: CellPosition | null | undefined): boolean;

package/dist/src/beta/components/Table/DataTable/internal/util/cellTypeHelpers.d.ts

@@ -1,41 +1,24 @@
 import { Cell } from '@tanstack/react-table';
 import { ColumnReadRenderResult } from '../../../types';
 /**
- * Extracts the column ID from a cell, with proper type narrowing.
- * Uses the stored ColumnDef from meta if available, otherwise falls back to column.id.
- *
- * @param cell - The TanStack table cell instance
- * @returns The column ID as a keyof T
+ * Leaf column `id` from `meta.columnDef` when present, else TanStack's string
+ * `column.id`.
  */
 export declare function getColumnId<T>(cell: Cell<T, unknown>): keyof T;
 /**
- * Gets the cell value with proper type narrowing based on column ID.
- * Uses the column ID to narrow the return type from `unknown` to `T[K]`.
- *
- * @param cell - The TanStack table cell instance
- * @param _columnId - The column ID to use for type narrowing (unused at runtime, only for TypeScript)
- * @returns The cell value, typed as T[K]
+ * Cell value as `T[K]`. TanStack's `Cell` type does not keep `T[K]` at the
+ * table instance, so this is an assertion.
  */
 export declare function getCellValue<T, K extends keyof T>(cell: Cell<T, unknown>, _columnId: K): T[K];
 export declare function getCellReadRenderResult<T>(cell: Cell<T, unknown>): ColumnReadRenderResult | undefined;
 export declare function getCellReadRenderRawString<T>(cell: Cell<T, unknown>): string | undefined;
 /**
- * Gets the onChange callback with proper typing based on column ID.
- * Returns a callback that accepts T[K] instead of the union type T[keyof T].
- *
- * @param cell - The TanStack table cell instance
- * @param _columnId - The column ID to use for type narrowing (unused at runtime, only for TypeScript)
- * @returns The onChange callback, typed to accept T[K], or undefined if not configured
+ * `editConfig.onChange` narrowed to `T[K]`. The config type is the column-id
+ * union, which is wider than one cell.
  */
 export declare function getCellOnChange<T, K extends keyof T>(cell: Cell<T, unknown>, _columnId: K): ((value: T[K], rowId: string) => void) | undefined;
 /**
- * Logs a warning when a cell value type doesn't match the expected type for its editMode.
- *
- * @param params - The warning parameters
- * @param params.columnId - The column ID for the warning message
- * @param params.editMode - The editMode of the column
- * @param params.expectedType - The expected type description
- * @param params.receivedType - The actual type received
+ * Warns when a cell value's runtime type does not match `editMode`.
  */
 export declare function logWarningForInvalidCellValueType({ columnId, editMode, expectedType, receivedType, }: {
     columnId: string;

package/dist/src/beta/components/Table/DataTable/internal/util/getCellInteractives.d.ts

@@ -1,22 +1,9 @@
 /**
- * Marker attribute applied the first time we manage an element's tabindex,
- * so we can find it again to flip the value back when entering interaction
- * mode regardless of what tabindex it currently has.
+ * Marks a descendant this cell owns so it can still be found after nav mode
+ * sets `tabIndex=-1`.
  */
 export declare const CELL_MANAGED_ATTR = "data-anv-cell-managed-tabindex";
-/**
- * Finds descendants of a cell that are currently tabbable but have not yet
- * been marked managed. Used by the immutable cell to discover newly rendered
- * focusables and bring them under tabindex control.
- *
- * @param cellEl The cell element to search within
- * @returns Tabbable descendants that are not yet under cell-tabindex control
- */
+/** Tabbable descendants not yet under this cell's tabindex control. */
 export declare function getUnmanagedTabbables(cellEl: HTMLElement): HTMLElement[];
-/**
- * Finds descendants the cell has previously brought under tabindex control.
- *
- * @param cellEl The cell element to search within
- * @returns Descendants previously marked as managed by the cell
- */
+/** Owned descendants, including nav-mode `tabIndex=-1` nodes a tabbable query would miss. */
 export declare function getManagedInteractives(cellEl: HTMLElement): HTMLElement[];

package/dist/src/beta/components/Table/DataTable/internal/util/getTanStackColumnDef.d.ts

@@ -6,9 +6,7 @@ declare module "@tanstack/react-table" {
         editMode?: EditMode;
         editConfig?: ColumnDef<TData>["editConfig"];
         overflow?: ColumnDef<TData>["overflow"];
-        /**
-         * The original column definition, stored for type narrowing and runtime access
-         */
+        /** Original Anvil column def, for type narrowing in cell helpers. */
         columnDef?: ColumnDef<TData>;
         /**
          * Custom read display metadata shared between rendering, editing, and sorting.
@@ -22,44 +20,22 @@ declare module "@tanstack/react-table" {
             row: TableRow<TData>;
             depth: number;
         }) => ColumnReadRenderResult;
-        /**
-         * Whether the header action (expand all / select all) is disabled for this column
-         */
+        /** Hides expand-all / select-all in this internal column's header. */
         disableHeaderAction?: boolean;
-        /**
-         * Resolved header alignment for DataTable-owned header layout.
-         */
         headerAlign?: HeaderAlign;
-        /**
-         * Whether this column renders a grouped header.
-         */
         isGroupHeader?: boolean;
     }
 }
-/**
- * Props for the getTanStackColumnDef function
- */
 export type TanStackColumnDefProps<T> = {
-    /**
-     * The column definition to convert to a TanStack column definition
-     */
+    /** Leaf or group; groups recurse via `columns`. */
     columnDef: ColumnDef<T>;
-    /**
-     * Table-level default content for empty cells. Column-level `emptyCellContent`
-     * takes precedence over this value.
-     */
     emptyCellContent?: ReactNode;
 };
 type TanStackColumnDef<T extends object> = ReturnType<ColumnHelper<T>["group"]> | ReturnType<ColumnHelper<T>["accessor"]>;
 type HeaderAlign = "start" | "center" | "end";
 /**
- * Build the column definition for TanStack useReactTable.
- * This converts our ColumnDef<T> to TanStack's column definition format,
- * preserving the original column definition in meta for type narrowing.
- *
- * @param props - The props for the getTanStackColumnDef function
- * @param props.columnDef - The column definition to convert
- * @returns The column definition for TanStack useReactTable
+ * Translates an Anvil {@link ColumnDef} into a TanStack column, storing the
+ * original def on `meta.columnDef` for later type narrowing.
  */
 export declare function getTanStackColumnDef<T extends object>({ columnDef, emptyCellContent, }: TanStackColumnDefProps<T>): TanStackColumnDef<T>;
 export {};

package/dist/src/beta/components/Table/DataTable/internal/util/shallowSortingEqual.d.ts

@@ -1,2 +1,3 @@
 import { SortingState } from '@tanstack/react-table';
+/** Same length and matching `id`/`desc` at each index; ignores extra fields. */
 export declare function shallowSortingEqual(a: SortingState, b: SortingState): boolean;

package/dist/src/beta/components/Table/DataTable/parts.d.ts

@@ -1,30 +1,16 @@
 /**
- * `data-anv-part` names for DataTable's interactive sub-elements.
- *
- * Scope a query by the consumer's `data-cy` on the DataTable root, then
- * narrow with existing discriminators:
- * - rows: `data-row-id`
- * - columns: `data-anv-column-id`
- *
- * Example: `[data-cy="orders"] [data-row-id="row-1"] [data-anv-part="select-checkbox"]`
+ * `data-anv-part` values for DataTable internals. Scope by the consumer's
+ * `data-cy` (or other `data-*`) on the root, then `data-row-id` /
+ * `data-anv-column-id`.
  */
 export declare const PARTS: {
-    /** Body row container (`role="row"`). */
     readonly row: "row";
-    /** Body cell (`role="gridcell"`). */
     readonly cell: "cell";
-    /** Sortable header cell (click target for column sort). */
     readonly sortToggle: "sort-toggle";
-    /** Per-row selection checkbox input. */
     readonly selectCheckbox: "select-checkbox";
-    /** Header select-all checkbox input. */
     readonly selectAllCheckbox: "select-all-checkbox";
-    /** Per-row expand/collapse button. */
     readonly expandButton: "expand-button";
-    /** Header expand-all button. */
     readonly expandAllButton: "expand-all-button";
-    /** Column resize handle. */
     readonly resizeHandle: "resize-handle";
-    /** Active text/number editor inside an editable cell. */
     readonly editableInput: "editable-input";
 };