@servicetitan/anvil2 3.0.1 → 3.0.2

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

@@ -5,25 +5,29 @@ import { Virtualizer } from '@tanstack/react-virtual';
  * than this many rows render all rows in the DOM (the pre-virtualization
  * behavior); tables with this many or more are virtualized.
  *
- * Set to 101 so tables with exactly 100 rows remain non-virtualized (and
+ * Set to 50 so tables with 49 or fewer rows remain non-virtualized (and
  * therefore keep every row — including any editable cells — fully mounted).
  */
-export declare const VIRTUALIZATION_THRESHOLD = 101;
+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`, signaling to the body that rows should
- * render via the non-virtualized flat flow.
+ * 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.
  *
  * @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.
  */
-export declare function useDataTableVirtualizer({ rowCount, scrollRef, disabled, }: {
+export declare function useDataTableVirtualizer({ rowCount, scrollRef, disabled, forced, }: {
     rowCount: number;
     scrollRef: RefObject<HTMLDivElement>;
     disabled?: boolean;
+    forced?: boolean;
 }): DataTableVirtualizer | undefined;

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

@@ -1,4 +1,5 @@
 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.
@@ -16,6 +17,8 @@ export declare function getColumnId<T>(cell: Cell<T, unknown>): keyof T;
  * @returns The cell value, typed as T[K]
  */
 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].

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

@@ -1,6 +1,6 @@
 import { ColumnHelper } from '@tanstack/react-table';
 import { ReactNode } from 'react';
-import { ColumnDef, EditMode } from '../../../types';
+import { ColumnDef, ColumnReadRenderResult, EditMode, TableRow } from '../../../types';
 declare module "@tanstack/react-table" {
     interface ColumnMeta<TData, TValue> {
         editMode?: EditMode;
@@ -9,6 +9,18 @@ declare module "@tanstack/react-table" {
          * The original column definition, stored for type narrowing and runtime access
          */
         columnDef?: ColumnDef<TData>;
+        /**
+         * Custom read display metadata shared between rendering, editing, and sorting.
+         */
+        readRenderResult?: ColumnReadRenderResult;
+        getCellText?: (value: TValue, context: {
+            row: TableRow<TData>;
+            depth: number;
+        }) => string;
+        getReadRenderResult?: (value: TValue, context: {
+            row: TableRow<TData>;
+            depth: number;
+        }) => ColumnReadRenderResult;
         /**
          * Whether the header action (expand all / select all) is disabled for this column
          */

package/dist/beta/components/Table/createColumnHelper.d.ts

@@ -1,10 +1,10 @@
 import { ReactNode } from 'react';
-import { ColumnDef, ColumnTypeConfig, TextEditConfig, NumberEditConfig, SelectEditConfig, SelectAsyncEditConfig, MultiselectEditConfig, MultiselectAsyncEditConfig, BooleanEditConfig, TableRow, ColumnHeaderConfig } from './types';
+import { ColumnDef, ColumnTypeConfig, TextEditConfig, NumberEditConfig, SelectEditConfig, SelectAsyncEditConfig, MultiselectEditConfig, MultiselectAsyncEditConfig, BooleanEditConfig, CustomEditConfig, TableRow, ColumnHeaderConfig, ColumnReadRenderContext, ColumnReadRenderResult } from './types';
 import { MultiSelectMenuOption } from '../MultiSelectMenu';
 /**
  * Base column configuration shared by all column types
  */
-type BaseColumnConfig<T, K extends keyof T> = ColumnHeaderConfig & {
+type BaseColumnConfig<T> = ColumnHeaderConfig & {
     /**
      * The cleaned-up header configuration.
      */
@@ -19,10 +19,6 @@ type BaseColumnConfig<T, K extends keyof T> = ColumnHeaderConfig & {
      * When using `type`, this is set automatically but can be overridden.
      */
     align?: "start" | "center" | "end";
-    /**
-     * Columns of a group column (for grouped columns)
-     */
-    columns?: ColumnDef<T>[];
     /**
      * Custom content to display when a cell value is empty (null, undefined, or empty string).
      * Overrides the default em dash. When set on both the column and the DataTable,
@@ -66,14 +62,26 @@ type BaseColumnConfig<T, K extends keyof T> = ColumnHeaderConfig & {
      * Whether the column is resizable
      */
     resizable?: boolean;
+};
+type BaseDataColumnConfig<T, K extends keyof T> = BaseColumnConfig<T> & {
     /**
      * The function to customize how the cell content is rendered.
      * When using `type`, a default renderer is provided but can be overridden.
      */
-    renderCell?: (value: T[K], { row, depth }: {
-        row?: TableRow<T>;
-        depth?: number;
-    }) => ReactNode;
+    renderCell?: (value: T[K], context: ColumnReadRenderContext<TableRow<T>>) => ReactNode;
+    /**
+     * Optional plain-text extractor for the read path.
+     * Useful when `renderCell` returns JSX or multiline content but default sorting
+     * should still use a simple string.
+     */
+    getCellText?: (value: T[K], context: ColumnReadRenderContext<TableRow<T>>) => string;
+    /**
+     * Optional advanced read-display extractor.
+     * Prefer `getCellText` for the common case where `renderCell` already handles
+     * display and sorting only needs a simple string. Use this when you want one
+     * hook to return both rendered read content and the sortable raw string.
+     */
+    getReadRenderResult?: (value: T[K], context: ColumnReadRenderContext<TableRow<T>>) => ColumnReadRenderResult;
     /**
      * Whether the column is sortable, or a function to customize the sorting logic
      */
@@ -84,36 +92,46 @@ type BaseColumnConfig<T, K extends keyof T> = ColumnHeaderConfig & {
      */
     type?: ColumnTypeConfig;
 };
+type GroupColumnConfig<T> = BaseColumnConfig<T> & {
+    /**
+     * Columns of a group column (for grouped columns)
+     */
+    columns: ColumnDef<T>[];
+    editConfig?: never;
+    renderCell?: never;
+    sortable?: never;
+    type?: never;
+};
 /**
  * Configuration for read-only columns (no editing)
  */
-type ReadOnlyColumnConfig<T, K extends keyof T> = BaseColumnConfig<T, K> & {
+type ReadOnlyColumnConfig<T, K extends keyof T> = BaseDataColumnConfig<T, K> & {
     editConfig?: undefined;
 };
 /**
  * Configuration for text editable columns using editConfig.
  * Valid when T[K] is a string.
  */
-type TextEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends string ? BaseColumnConfig<T, K> & {
+type TextEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends string ? BaseDataColumnConfig<T, K> & {
     editConfig: TextEditConfig<T, K>;
 } : never;
 /**
  * Configuration for number editable columns using editConfig.
  * Valid when T[K] is a number type.
  */
-type NumberEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends number ? BaseColumnConfig<T, K> & {
+type NumberEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends number ? BaseDataColumnConfig<T, K> & {
     editConfig: NumberEditConfig<T, K>;
 } : never;
 /**
  * Configuration for select editable columns using editConfig
  */
-type SelectEditConfigColumnConfig<T, K extends keyof T> = BaseColumnConfig<T, K> & {
+type SelectEditConfigColumnConfig<T, K extends keyof T> = BaseDataColumnConfig<T, K> & {
     editConfig: SelectEditConfig<T, K>;
 };
 /**
  * Configuration for async select editable columns using editConfig
  */
-type SelectAsyncEditConfigColumnConfig<T, K extends keyof T> = BaseColumnConfig<T, K> & {
+type SelectAsyncEditConfigColumnConfig<T, K extends keyof T> = BaseDataColumnConfig<T, K> & {
     editConfig: SelectAsyncEditConfig<T>;
 };
 type CellArrayItem = object | string | number | boolean | bigint | symbol | null | undefined;
@@ -122,7 +140,7 @@ type CellArrayValue = readonly CellArrayItem[];
  * Configuration for multiselect editable columns using editConfig
  * Only valid when T[K] is an array type
  */
-type MultiselectEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends CellArrayValue ? BaseColumnConfig<T, K> & {
+type MultiselectEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends CellArrayValue ? BaseDataColumnConfig<T, K> & {
     editConfig: MultiselectEditConfig<T, K>;
 } : never;
 /**
@@ -130,21 +148,24 @@ type MultiselectEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]>
  * Only valid when T[K] is MultiSelectMenuOption[] — full option objects,
  * not a plain primitive array like string[].
  */
-type MultiselectAsyncEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends MultiSelectMenuOption[] ? BaseColumnConfig<T, K> & {
+type MultiselectAsyncEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends MultiSelectMenuOption[] ? BaseDataColumnConfig<T, K> & {
     editConfig: MultiselectAsyncEditConfig<T>;
 } : never;
 /**
  * Configuration for boolean editable columns using editConfig.
  * Valid when T[K] is a boolean type.
  */
-type BooleanEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends boolean ? BaseColumnConfig<T, K> & {
+type BooleanEditConfigColumnConfig<T, K extends keyof T> = NonNullable<T[K]> extends boolean ? BaseDataColumnConfig<T, K> & {
     editConfig: BooleanEditConfig<T, K>;
 } : never;
+type CustomEditConfigColumnConfig<T, K extends keyof T> = BaseDataColumnConfig<T, K> & {
+    editConfig: CustomEditConfig<T, K>;
+};
 /**
  * Full column configuration type - union of all possible configurations.
  * TypeScript will enforce that the editConfig matches the value type constraints.
  */
-type ColumnConfig<T, K extends keyof T> = ReadOnlyColumnConfig<T, K> | TextEditConfigColumnConfig<T, K> | NumberEditConfigColumnConfig<T, K> | SelectEditConfigColumnConfig<T, K> | SelectAsyncEditConfigColumnConfig<T, K> | MultiselectEditConfigColumnConfig<T, K> | MultiselectAsyncEditConfigColumnConfig<T, K> | BooleanEditConfigColumnConfig<T, K>;
+type ColumnConfig<T, K extends keyof T> = ReadOnlyColumnConfig<T, K> | TextEditConfigColumnConfig<T, K> | NumberEditConfigColumnConfig<T, K> | SelectEditConfigColumnConfig<T, K> | SelectAsyncEditConfigColumnConfig<T, K> | MultiselectEditConfigColumnConfig<T, K> | MultiselectAsyncEditConfigColumnConfig<T, K> | BooleanEditConfigColumnConfig<T, K> | CustomEditConfigColumnConfig<T, K>;
 /**
  * Factory function to create column helper function for defining Table columns.
  *
@@ -156,7 +177,9 @@ type ColumnConfig<T, K extends keyof T> = ReadOnlyColumnConfig<T, K> | TextEditC
  * - `editConfig.mode: "number"` can only be used with number columns
  * - `editConfig.mode: "multiselect"` can only be used with array columns
  * - `editConfig.mode: "select"` options values must match the column's value type
+ * - `editConfig.mode: "custom"` preserves object-valued canonical state and typed draft helpers
  * - `editConfig.onChange` callback receives the correct value type for the column
+ * - `getCellText` provides a simple sortable read string when `renderCell` returns rich content
  *
  * @template T - The type of the row data
  * @returns A function that creates type-safe column definitions
@@ -209,7 +232,10 @@ type ColumnConfig<T, K extends keyof T> = ReadOnlyColumnConfig<T, K> | TextEditC
  * });
  * ```
  */
-export declare function createColumnHelper<T>(): <K extends keyof T>(id: K | {
-    group: string;
-}, column: ColumnConfig<T, K>) => ColumnDef<T>;
+export declare function createColumnHelper<T>(): {
+    (id: {
+        group: string;
+    }, column: GroupColumnConfig<T>): ColumnDef<T>;
+    <K extends keyof T>(id: K, column: ColumnConfig<T, K>): ColumnDef<T>;
+};
 export {};

package/dist/beta/components/Table/internal/getCommonPinningClasses.d.ts

@@ -1,5 +1,5 @@
 import { Column } from '@tanstack/react-table';
 /**
- * Get the common classes for adding shadow styles to pinned columns
+ * Get the pinning-related classes for a column (overflow gradient + padding-strip bg extension).
  */
 export declare const getCommonPinningClasses: <T>(column: Column<T>) => string | undefined;

package/dist/beta/components/Table/types.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode } from 'react';
+import { KeyboardEvent as ReactKeyboardEvent, ReactNode, SetStateAction } from 'react';
 import { BooleanFormatterOptions, CurrencyFormatterOptions, DateFormatterOptions, DateTimeFormatterOptions, NumberFormatterOptions, PercentFormatterOptions, TimeFormatterOptions } from './formatters';
 import { SelectMenuOption, SelectMenuGroupByValue } from '../SelectMenu';
 import { SelectMenuSyncProps } from '../SelectMenu/SelectMenuSync';
@@ -47,7 +47,7 @@ export type ColumnTypeConfig<T extends ColumnType = ColumnType> = T | {
 /**
  * Edit mode literals for editable cells.
  */
-export type EditMode = "text" | "number" | "select" | "select-async" | "multiselect" | "multiselect-async" | "boolean";
+export type EditMode = "text" | "number" | "select" | "select-async" | "multiselect" | "multiselect-async" | "boolean" | "custom";
 /**
  * Base edit configuration shared by all edit modes.
  * @template T - The row data type
@@ -61,6 +61,196 @@ type BaseEditConfig<T, K extends keyof T> = {
      */
     onChange: (value: T[K], rowId: string) => void;
 };
+type CustomEditCanonicalValueForValue<TValue> = TValue extends readonly (infer _Element)[] ? never : TValue extends object ? NonNullable<TValue> : never;
+type CustomEditCanonicalValue<T, K extends keyof T> = CustomEditCanonicalValueForValue<NonNullable<T[K]>>;
+export type CustomEditFieldValueUpdater<TValue extends object, TField extends keyof TValue> = TValue[TField] | ((previousValue: TValue[TField], draftValue: TValue) => TValue[TField]);
+export type CustomEditCloseReason = "submit" | "escape" | "outside-click" | "close-button" | "programmatic";
+export type CustomEditValidation<TValue extends object> = {
+    /**
+     * Form-level validation summary for the entire editor.
+     */
+    formError?: ReactNode;
+    /**
+     * Field-level validation messages keyed by draft field.
+     */
+    fieldErrors?: Partial<Record<keyof TValue, ReactNode>>;
+};
+export type CustomEditSurfaceConfig = {
+    /**
+     * Optional title rendered in the editor surface header.
+     */
+    title?: ReactNode;
+    /**
+     * Optional surface width.
+     */
+    width?: number | string;
+    /**
+     * Optional surface max height.
+     */
+    maxHeight?: number | string;
+    /**
+     * Accessible label for the close button.
+     */
+    closeButtonLabel?: string;
+    /**
+     * Optional keydown handler forwarded to the surface.
+     */
+    onKeyDown?: (event: ReactKeyboardEvent<HTMLDivElement>) => void;
+};
+export type CustomEditCloseRequest<TValue extends object> = {
+    /**
+     * Why the close was requested.
+     */
+    reason: CustomEditCloseReason;
+    /**
+     * Draft value at the time the request is evaluated.
+     */
+    draftValue: TValue;
+    /**
+     * Original committed value when editing began.
+     */
+    initialValue: TValue;
+    /**
+     * Whether the draft differs from the initial value.
+     */
+    isDirty: boolean;
+    /**
+     * Current validation metadata.
+     */
+    validation: CustomEditValidation<TValue>;
+};
+export type CustomEditController<TValue extends object> = {
+    /**
+     * Current local draft value owned by the custom editor.
+     */
+    draftValue: TValue;
+    /**
+     * Original value before editing began.
+     */
+    initialValue: TValue;
+    /**
+     * Whether the draft differs from the initial value.
+     */
+    isDirty: boolean;
+    /**
+     * Ordered list of changed fields.
+     */
+    changedFields: ReadonlyArray<keyof TValue>;
+    /**
+     * Current validation metadata for the draft.
+     */
+    validation: CustomEditValidation<TValue>;
+    /**
+     * Replace the entire draft value.
+     */
+    setDraftValue: (nextValue: SetStateAction<TValue>) => TValue;
+    /**
+     * Update a single field in the current draft value.
+     */
+    setDraftField: <TField extends keyof TValue>(field: TField, nextValue: CustomEditFieldValueUpdater<TValue, TField>) => TValue;
+    /**
+     * Submit the current draft and close the editor.
+     */
+    submit: () => void;
+    /**
+     * Restore the initial value and close the editor.
+     */
+    discard: () => void;
+    /**
+     * Request closure using the configured policy for the supplied reason.
+     */
+    requestClose: (reason: CustomEditCloseReason) => void;
+    /**
+     * Register the one preferred initial-focus action for the editor.
+     */
+    setInitialFocus: (focus: (() => void) | null) => void;
+    /**
+     * Canonical submit handler for form-based editors.
+     */
+    handleSubmit: (event?: {
+        preventDefault?: () => void;
+    }) => void;
+};
+export type ColumnReadRenderContext<T> = {
+    row: T;
+    depth: number;
+};
+export type ColumnReadRenderResult = {
+    /**
+     * Advanced read-path rendered content.
+     * Most consumers should prefer `renderCell` + `getCellText` and only use
+     * this shape when one hook should return both rendered content and sortable text.
+     */
+    content: ReactNode;
+    /**
+     * Optional sortable plain-text representation of the rendered content.
+     */
+    rawString?: string;
+};
+export type CustomEditRenderContext<T, K extends keyof T> = {
+    /**
+     * Full row data for the cell being edited.
+     */
+    row: T;
+    /**
+     * String row id for the cell being edited.
+     */
+    rowId: string;
+    /**
+     * Canonical committed value for the cell.
+     */
+    value: T[K];
+    /**
+     * Typed controller for draft mutation, validation, focus, and lifecycle control.
+     */
+    controller: CustomEditController<CustomEditCanonicalValue<T, K>>;
+};
+/**
+ * Edit configuration for custom mode cells.
+ * Preserves canonical object values while continuing to use `renderCell`
+ * for the read path.
+ *
+ * @template T - The row data type
+ * @template K - The column key
+ */
+export type CustomEditConfig<T, K extends keyof T> = [
+    CustomEditCanonicalValue<T, K>
+] extends [never] ? never : Omit<BaseEditConfig<T, K>, "onChange"> & {
+    /**
+     * Custom edit mode - renders a multi-field editor surface.
+     */
+    mode: "custom";
+    /**
+     * Callback fired when the draft is committed.
+     */
+    onCommit: (value: T[K], rowId: string) => void;
+    /**
+     * Callback fired on every local draft mutation.
+     */
+    onDraftUpdate?: (value: T[K], rowId: string) => void;
+    /**
+     * Optional validation metadata derived from the current draft.
+     */
+    validateDraft?: (draftValue: CustomEditCanonicalValue<T, K>, rowId: string) => CustomEditValidation<CustomEditCanonicalValue<T, K>> | undefined;
+    /**
+     * When true, submit-style close requests are blocked while validation contains
+     * a form error or any field error. Defaults to `false`.
+     */
+    blockOnValidationError?: boolean;
+    /**
+     * Optional close interception hook.
+     * Return `false` to keep the editor open.
+     */
+    onRequestClose?: (request: CustomEditCloseRequest<CustomEditCanonicalValue<T, K>>) => boolean | void;
+    /**
+     * Optional surface presentation overrides.
+     */
+    surface?: CustomEditSurfaceConfig;
+    /**
+     * Consumer-owned renderer for the custom editor contents.
+     */
+    renderEditor: (context: CustomEditRenderContext<T, K>) => ReactNode;
+};
 /**
  * Edit configuration for text mode cells.
  * @template T - The row data type
@@ -407,9 +597,17 @@ export type BooleanEditConfig<T, K extends keyof T> = BaseEditConfig<T, K> & {
  *   falseLabel: "No",
  *   onChange: (value, rowId) => save(value, rowId)
  * }
+ *
+ * // Custom editing keeps renderCell as the read path
+ * editConfig: {
+ *   mode: "custom",
+ *   onChange: (value, rowId) => save(value, rowId),
+ *   onDraftChange: (value, rowId) => saveDraft(value, rowId),
+ *   renderEditor: ({ helpers }) => renderAddressEditor(helpers)
+ * }
  * ```
  */
-export type EditConfig<T, K extends keyof T> = TextEditConfig<T, K> | NumberEditConfig<T, K> | SelectEditConfig<T, K> | SelectAsyncEditConfig<T> | MultiselectEditConfig<T, K> | MultiselectAsyncEditConfig<T> | BooleanEditConfig<T, K>;
+export type EditConfig<T, K extends keyof T> = TextEditConfig<T, K> | NumberEditConfig<T, K> | SelectEditConfig<T, K> | SelectAsyncEditConfig<T> | MultiselectEditConfig<T, K> | MultiselectAsyncEditConfig<T> | BooleanEditConfig<T, K> | CustomEditConfig<T, K>;
 /**
  * The type for a table row
  * @extends T
@@ -459,6 +657,101 @@ export type TableRow<T> = T & {
      */
     subRows?: TableRow<T>[];
 };
+export type ColumnBaseDef = {
+    /**
+     * The label of the header
+     */
+    headerLabel: string;
+    /**
+     * The alignment of the header and cell content.
+     * When using `type`, this is set automatically but can be overridden.
+     */
+    align?: "start" | "center" | "end";
+    /**
+     * Custom content to display when a cell value is empty (null, undefined, or empty string).
+     * Overrides the default em dash. When set on both the column and the DataTable,
+     * the column-level value takes precedence.
+     */
+    emptyCellContent?: ReactNode;
+    /**
+     * The content of the footer cell. An array will display multiple footer rows
+     */
+    footerContent?: ReactNode | ReactNode[];
+    /**
+     * The maximum width of the column, in pixels
+     */
+    maxWidth?: number;
+    /**
+     * The minimum width of the column, in pixels
+     */
+    minWidth?: number;
+    /**
+     * The pinning location of the column
+     */
+    pinned?: "left" | "right";
+    /**
+     * Whether the column is resizable
+     */
+    resizable?: boolean;
+};
+export type ColumnGroupDef<T> = ColumnBaseDef & {
+    /**
+     * Group column id.
+     */
+    id: string;
+    /**
+     * Columns of a group column
+     */
+    columns: ColumnDef<T>[];
+    editConfig?: never;
+    renderCell?: never;
+    sortable?: never;
+    type?: never;
+};
+export type ColumnDefForKey<T, K extends keyof T> = ColumnBaseDef & {
+    /**
+     * The id of the column - must be a key of T
+     */
+    id: K;
+    /**
+     * Columns of a group column
+     */
+    columns?: undefined;
+    /**
+     * Configuration for cell editing. Presence enables editing for the column.
+     * Consolidates edit mode, options, and onChange into a single object.
+     */
+    editConfig?: EditConfig<T, K>;
+    /**
+     * The function to customize how the cell content is rendered.
+     * When using `type`, a default renderer is provided but can be overridden.
+     * Custom edit columns continue to use this read-only render path.
+     */
+    renderCell?: (value: T[K], context: ColumnReadRenderContext<TableRow<T>>) => ReactNode;
+    /**
+     * Optional plain-text extractor for the read path.
+     * Useful when `renderCell` returns JSX or multiline content but default sorting
+     * should still use a simple string.
+     */
+    getCellText?: (value: T[K], context: ColumnReadRenderContext<TableRow<T>>) => string;
+    /**
+     * Optional advanced read-display extractor.
+     * Prefer `getCellText` for the common case where `renderCell` already handles
+     * display and sorting only needs a simple string. Use this when you want one
+     * hook to return both rendered read content and the sortable raw string.
+     */
+    getReadRenderResult?: (value: T[K], context: ColumnReadRenderContext<TableRow<T>>) => ColumnReadRenderResult;
+    /**
+     * Whether the column is sortable, or a function to customize the sorting logic.
+     * When a function, receives values of the column's value type.
+     */
+    sortable?: boolean | ((valueA: T[K], valueB: T[K]) => number);
+    /**
+     * The column type for automatic display configuration.
+     * Sets default `renderCell` (formatter) and `align` based on the data type.
+     */
+    type?: ColumnTypeConfig;
+};
 /**
  * Column definition type for DataTable columns.
  *
@@ -606,11 +899,22 @@ export type ColumnDef<T> = ColumnHeaderConfig & {
     /**
      * The function to customize how the cell content is rendered.
      * When using `type`, a default renderer is provided but can be overridden.
+     * Custom edit columns continue to use this read-only render path.
+     */
+    renderCell?: (value: T[keyof T], context: ColumnReadRenderContext<TableRow<T>>) => ReactNode;
+    /**
+     * Optional plain-text extractor for the read path.
+     * Useful when `renderCell` returns JSX or multiline content but default sorting
+     * should still use a simple string.
+     */
+    getCellText?: (value: T[keyof T], context: ColumnReadRenderContext<TableRow<T>>) => string;
+    /**
+     * Optional advanced read-display extractor.
+     * Prefer `getCellText` for the common case where `renderCell` already handles
+     * display and sorting only needs a simple string. Use this when you want one
+     * hook to return both rendered read content and the sortable raw string.
      */
-    renderCell?: (value: T[keyof T], { row, depth }: {
-        row?: T;
-        depth?: number;
-    }) => ReactNode;
+    getReadRenderResult?: (value: T[keyof T], context: ColumnReadRenderContext<TableRow<T>>) => ColumnReadRenderResult;
     /**
      * Whether the column is resizable
      */

package/dist/beta/components/index.d.ts

@@ -7,3 +7,4 @@ export * from './MultiSelectField';
 export * from './SelectMenu';
 export * from './MultiSelectMenu';
 export * from './InteractiveCard';
+export * from './RichTextEditor';

package/dist/beta.js

@@ -1,13 +1,14 @@
-export { F as FilterBar } from './FilterBar-BU8StPPd.js';
-export { C as COLUMN_TYPE_DEFAULTS, D as DataTable, b as booleanFormatter, a as chipsFormatter, c as createColumnHelper, d as currencyFormatter, i as dateFormatPresets, e as dateFormatter, f as dateTimeFormatter, g as getColumnTypeDefaults, h as htmlFormatter, m as markdownFormatter, n as numberFormatter, p as percentFormatter, r as resolveColumnTypeConfig, t as timeFormatPresets, j as timeFormatter, y as yearlessDateFormatter } from './DataTable-BDXdCF7J.js';
-export { T as Toolbar, a as ToolbarButton, b as ToolbarButtonLink, d as ToolbarControlGroup, f as ToolbarElement, e as ToolbarSearchField, c as ToolbarSelect } from './Toolbar-Dzj2KMEy.js';
-export { T as ToolbarButtonToggle } from './ToolbarButtonToggle--2Ka05N8.js';
-export { u as useCalendarBetaProps } from './Calendar-CaCMa_jq.js';
-export { C as Calendar } from './Calendar-BAbAagIx.js';
-export { S as SelectField, a as SelectFieldSync } from './SelectFieldSync-W_-jTf7z.js';
-export { M as MultiSelectField, a as MultiSelectFieldSync } from './MultiSelectFieldSync-ueey5UBM.js';
-export { S as SelectMenu, a as SelectMenuSync } from './SelectMenuSync-QcjbQtCO.js';
-export { M as MultiSelectMenu, a as MultiSelectMenuSync } from './MultiSelectMenuSync-D7hqugcQ.js';
-export { I as InteractiveCard } from './InteractiveCard-CnW0m_F-.js';
-export { u as useAdaptiveView } from './syncFilterUtils-nJS_tCsu.js';
+export { F as FilterBar } from './FilterBar-kVue-bVK.js';
+export { C as COLUMN_TYPE_DEFAULTS, D as DataTable, b as booleanFormatter, a as chipsFormatter, c as createColumnHelper, d as currencyFormatter, i as dateFormatPresets, e as dateFormatter, f as dateTimeFormatter, g as getColumnTypeDefaults, h as htmlFormatter, m as markdownFormatter, n as numberFormatter, p as percentFormatter, r as resolveColumnTypeConfig, t as timeFormatPresets, j as timeFormatter, y as yearlessDateFormatter } from './DataTable-CB-exG-7.js';
+export { T as Toolbar, a as ToolbarButton, b as ToolbarButtonLink, d as ToolbarControlGroup, f as ToolbarElement, e as ToolbarSearchField, c as ToolbarSelect } from './Toolbar-J5cakHba.js';
+export { T as ToolbarButtonToggle } from './ToolbarButtonToggle-Ch0SH4oH.js';
+export { u as useCalendarBetaProps } from './Calendar-Dtn07sfJ.js';
+export { C as Calendar } from './Calendar-BLvBN8Ou.js';
+export { S as SelectField, a as SelectFieldSync } from './SelectFieldSync-BbJFd_bV.js';
+export { M as MultiSelectField, a as MultiSelectFieldSync } from './MultiSelectFieldSync-BWZQ4MFC.js';
+export { S as SelectMenu, a as SelectMenuSync } from './SelectMenuSync-CBMdmGTU.js';
+export { M as MultiSelectMenu, a as MultiSelectMenuSync } from './MultiSelectMenuSync-Bl4ty0je.js';
+export { I as InteractiveCard } from './InteractiveCard-KGs2b_al.js';
+export { R as RichTextEditor } from './RichTextEditor-C_Boj8QP.js';
+export { u as useAdaptiveView } from './syncFilterUtils-Gvm81gyv.js';
 //# sourceMappingURL=beta.js.map

package/dist/beta.js.map

@@ -1 +1 @@
-{"version":3,"file":"beta.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}
+{"version":3,"file":"beta.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/dist/components/Toolbar/internal/utils/accessibility.d.ts

@@ -1,4 +1,9 @@
 import { KeyboardEvent } from 'react';
+/**
+ * Gets all visible focusable elements for a specific toolbar instance.
+ * Filters out hidden items and includes the overflow trigger if present.
+ */
+export declare function getToolbarElements(toolbarElement: HTMLElement): Element[];
 /**
  * Updates tabindex values for all items in a toolbar.
  * Sets tabindex="0" for the active item and tabindex="-1" for all others.