@servicetitan/anvil2 3.0.1 → 3.0.3

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

@@ -1,4 +1,5 @@
 import { Row } from '@tanstack/react-table';
+import { TableRow } from '../../types';
 import { useColumnOrder } from './useColumnOrder';
 export type DataTableBodyRowProps<T> = {
     columnOrder: ReturnType<typeof useColumnOrder>["columnOrder"];
@@ -11,6 +12,22 @@ export type DataTableBodyRowProps<T> = {
     parentRowCanExpand: boolean;
     isSelected: boolean;
     isSomeSelected: boolean;
+    isActivatable: boolean;
+    isActive: boolean;
+    /**
+     * True when the row is the topmost active ancestor in its active chain
+     * (itself active, has sub-rows, and no ancestor row is active). Drives
+     * the darker blue/100 background; non-topmost active rows use blue/50.
+     */
+    isTopMostActive: boolean;
+    /**
+     * True when the row is flagged read-only via `readOnlyRowIds`. Grays
+     * plain text, shows `not-allowed` cursor on activatable rows, and
+     * disables the activation click (checkbox disabling is gated at the
+     * DataTable level via `enableRowSelection`).
+     */
+    isReadOnly: boolean;
+    onToggleActive: (rowId: TableRow<T>["id"], descendantIds: TableRow<T>["id"][]) => void;
     /**
      * Optional consumer-provided function that returns a value expressing
      * "this row has changed." When supplied, the row is memoized: a row will
@@ -21,6 +38,6 @@ export type DataTableBodyRowProps<T> = {
      */
     getRowVersion?: (row: T) => unknown;
 };
-declare function DataTableBodyRowInner<T>({ columnOrder, row, rowIndex, tableHasSubRows, isExpanded, canExpand, depth, parentRowCanExpand, }: DataTableBodyRowProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function DataTableBodyRowInner<T>({ columnOrder, row, rowIndex, tableHasSubRows, isExpanded, canExpand, depth, parentRowCanExpand, isActivatable, isActive, isTopMostActive, isReadOnly, onToggleActive, }: DataTableBodyRowProps<T>): import("react/jsx-runtime").JSX.Element;
 export declare const DataTableBodyRow: typeof DataTableBodyRowInner;
 export {};

package/dist/beta/components/Table/DataTable/internal/cells/CellFocusContext.d.ts

@@ -0,0 +1,16 @@
+export type CellFocusContextValue = {
+    /**
+     * Whether the cell currently has focus
+     */
+    isCellFocused: boolean;
+};
+/**
+ * Context for communicating cell focus state to child components.
+ * Used by CellStatus to show tooltips when the cell is focused via keyboard.
+ */
+export declare const CellFocusContext: import('react').Context<CellFocusContextValue | null>;
+/**
+ * Hook to consume the CellFocusContext.
+ * Returns null if used outside of a CellFocusContext.Provider.
+ */
+export declare function useCellFocusContext(): CellFocusContextValue | null;

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

@@ -0,0 +1,8 @@
+import { BaseEditableCellProps, EditableCellImperativeHandle } from './types';
+type DataTableEditableCustomCellProps<T> = BaseEditableCellProps<T>;
+export declare const DataTableEditableCustomCell: (<T>(props: DataTableEditableCustomCellProps<T> & {
+    ref?: React.Ref<EditableCellImperativeHandle>;
+}) => React.ReactElement) & {
+    displayName: string;
+};
+export {};

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

@@ -0,0 +1,49 @@
+import { CustomEditConfig, CustomEditController, CustomEditRenderContext, TableRow } from '../../../types';
+type CustomObjectValue = object;
+type CustomEditHelperValue<T, K extends keyof T> = CustomEditRenderContext<T, K>["controller"]["draftValue"];
+/**
+ * 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> = {
+    controller: CustomEditController<TValue>;
+    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: TableRow<T>;
+    columnId: K;
+    editConfig: CustomEditConfig<T, K>;
+    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.
+ */
+export declare function useCustomEditControllerState<T, K extends keyof T>({ row, columnId, editConfig, onCloseEditor, }: UseCustomEditControllerStateOptions<T, K>): CustomEditControllerState<CustomEditHelperValue<T, K>>;
+/**
+ * Backward-compatible alias for the custom edit controller hook.
+ */
+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.
+ */
+export declare function createCustomEditControllerState<T, K extends keyof T>({ row, columnId, editConfig, onCloseEditor, }: UseCustomEditControllerStateOptions<T, K>): CustomEditControllerState<CustomEditHelperValue<T, K>>;
+/**
+ * Backward-compatible alias for the imperative custom edit controller factory.
+ */
+export declare const createCustomEditHelperState: typeof createCustomEditControllerState;
+export {};

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;