@servicetitan/anvil2 3.14.1 → 3.15.1

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

@@ -2,88 +2,70 @@ import { ReactNode } from 'react';
 import { TableRow } from '../types';
 import { Svg } from '../../../../types';
 /**
- * Represents a sorted column configuration for DataTable
+ * Single-column sort. DataTable only applies `sorting[0]`.
  */
 export type SortedColumn = {
-    /**
-     * The column identifier
-     */
+    /** Matches a column `id`. */
     id: string;
-    /**
-     * Whether the column is sorted in descending order
-     */
+    /** `true` is descending. */
     desc: boolean;
 };
 /**
- * Configuration for the empty state displayed when the DataTable has no data
+ * Empty-body illustration and copy. Shown when the current page has no rows
+ * and the table is not loading — including an empty page of a larger dataset.
  */
 export type DataTableEmptyState = {
     /**
-     * Optional SVG illustration component to display.
-     * Pass a single SVG component, or an object with `light` and `dark` properties
-     * to display different illustrations based on the user's color scheme preference.
+     * One SVG component, or `{ light, dark }` to follow the theme. Missing
+     * scheme falls back to the other. Pairs that are not components are ignored.
      */
     svg?: Svg | {
         light?: Svg;
         dark?: Svg;
     };
-    /**
-     * Optional content to display below the illustration
-     */
+    /** Rendered under the illustration. */
     content?: ReactNode;
 };
 /**
- * Configuration for caching loadPageData results in DataTable.
- * When enabled, resolved page data is cached per page index, allowing
- * instant restoration when returning to a previously loaded page.
- * @property {boolean} [enabled] - Whether caching is enabled. Defaults to true.
- * @property {number} [maxSize] - Maximum number of pages to cache. Oldest entry is evicted (FIFO) when the limit is reached. Defaults to 15.
+ * `loadPageData` page cache. Hits restore a page without calling the loader.
  */
 export type DataTableCacheOptions = {
     /**
-     * Whether caching is enabled.
-     * @default true
+     * When `false`, every `getOrLoad` calls the loader. Defaults to `true`.
      */
     enabled?: boolean;
     /**
-     * Maximum number of pages to cache. When the limit is reached, the oldest cached page is
-     * evicted (FIFO) to make room for the new entry.
-     * @default 15
+     * Max pages kept, FIFO by insertion. Defaults to `15`.
      */
     maxSize?: number;
 };
 /**
- * Pagination behavior for DataTable.
- * "offset" uses numbered pages with a known total row count.
- * "cursor" uses previous/next availability for unknown-total pagination.
+ * `"offset"` is numbered pages with a known total. `"cursor"` is prev/next
+ * when the total is unknown.
  */
 export type DataTablePaginationMode = "offset" | "cursor";
 type DataTablePaginationBaseConfig<T> = {
     /**
-     * Number of rows displayed per page
-     * @default 25
+     * Rows on each page. Defaults to `25`.
      */
     rowsPerPage?: number;
     /**
-     * Available options for rows per page selection
-     * @default [25, 50, 100]
+     * Values for the rows-per-page control. Defaults to `[25, 50, 100]`.
+     * In cursor mode the control is omitted unless `onRowsPerPageChange` is set.
      */
     rowsPerPageOptions?: number[];
     /**
-     * Callback when rows per page changes
+     * Fires when the rows-per-page control commits a new size.
      */
     onRowsPerPageChange?: (rowsPerPage: number) => void;
     /**
-     * Current page index (0-based)
+     * Controlled 0-based page. Omit for uncontrolled (`defaultPageIndex`).
      */
     currentPageIndex?: number;
     /**
-     * Function to get the data for the current page. When used, the data displayed will be
-     * fully controlled by the implementor. This is useful for server-side pagination scenarios where
-     * the total number of rows may differ from the data array length.
-     *
-     * The `sorting` parameter is provided when a column is sorted, allowing the server
-     * to return data in the correct sort order.
+     * Server (or otherwise owned) page fetch. Turns on manual pagination and
+     * manual sorting so TanStack does not re-slice or re-sort the returned rows.
+     * `sorting` is the active {@link SortedColumn} when a column is sorted.
      */
     loadPageData?: ({ pageIndex, pageSize, sorting, }: {
         pageIndex: number;
@@ -91,40 +73,36 @@ type DataTablePaginationBaseConfig<T> = {
         sorting?: SortedColumn;
     }) => TableRow<T>[] | Promise<TableRow<T>[]>;
     /**
-     * Default page index for uncontrolled mode (0-based)
-     * @default 0
+     * Uncontrolled starting page. Defaults to `0`.
      */
     defaultPageIndex?: number;
     /**
-     * Callback when page changes. Receives the new page index (0-based)
+     * Fires with the new 0-based page.
      */
     onPageChange?: (pageIndex: number) => void;
     /**
-     * Key that triggers data refetch when changed.
-     * Useful for forcing refetch when external filters change.
-     * When changed, the page index automatically resets to 0.
+     * Identity that refetches page data and resets the page to `0` when it
+     * changes after mount. Use for filters that live outside the table.
      */
     refreshKey?: string | number;
     /**
-     * Configuration for caching loadPageData results.
-     * Caching is enabled by default. Set `{ enabled: false }` to disable.
+     * {@link DataTableCacheOptions} for `loadPageData`. Offset defaults on;
+     * cursor defaults `{ enabled: false }` when this is omitted.
      */
     cache?: DataTableCacheOptions;
 };
 export type DataTableOffsetPaginationConfig<T> = DataTablePaginationBaseConfig<T> & {
     /**
-     * Offset pagination mode.
-     * @default "offset"
+     * Numbered pages. Defaults to `"offset"` when `mode` is omitted.
      */
     mode?: "offset";
     /**
-     * Whether to display the item count information in pagination
-     * @default true
+     * Shows "x–y of z" in the pager. Defaults to `true`.
      */
     showCount?: boolean;
     /**
-     * Total number of rows across all pages in offset mode. Falls back to data.length if not provided.
-     * Useful for server-side pagination scenarios where totalRowCount may differ from data array length.
+     * Total rows across pages. Falls back to the loaded array length when
+     * omitted — pass this when `loadPageData` returns only the current page.
      */
     totalRowCount?: number;
     hasNextPage?: never;
@@ -132,38 +110,37 @@ export type DataTableOffsetPaginationConfig<T> = DataTablePaginationBaseConfig<T
 };
 export type DataTableCursorPaginationConfig<T> = DataTablePaginationBaseConfig<T> & {
     /**
-     * Cursor pagination mode for datasets where the total row count is unknown.
+     * Prev/next pager when the total row count is unknown.
      */
     mode: "cursor";
     /**
-     * Whether another page is available.
+     * Enables Next. Required in cursor mode.
      */
     hasNextPage: boolean;
     /**
-     * Whether a previous page is available.
+     * Enables Previous. Required in cursor mode.
      */
     hasPrevPage: boolean;
     showCount?: never;
     totalRowCount?: never;
 };
 /**
- * Configuration for pagination in DataTable
+ * Offset (numbered, known total) or cursor (prev/next, unknown total).
  */
 export type DataTablePaginationConfig<T> = DataTableOffsetPaginationConfig<T> | DataTableCursorPaginationConfig<T>;
 /**
- * Ref handle for DataTable component
- * @property {function} refresh - Triggers a data refetch and resets the page index to 0. Useful for manually refreshing data after external changes (e.g., after a mutation).
- * @property {function} clearCache - Clears the page data cache without triggering a refetch.
+ * Imperative handle: refetch the current loader, or drop cached pages.
  */
 export type DataTableRef = {
     /**
-     * Triggers a data refetch and resets the page index to 0.
-     * Useful for manually refreshing data after external changes (e.g., after a mutation).
-     * When using controlled pagination, this will call `onPageChange(0)`.
+     * Bumps the internal refresh counter and sets the page to `0` (calls
+     * `onPageChange(0)` when page is controlled). Does not by itself call
+     * `clearCache`.
      */
     refresh: () => void;
     /**
-     * Clears the page data cache without triggering a refetch.
+     * Drops cached pages without refetching. The current page stays until
+     * `refresh` or a cache-invalidating input changes.
      */
     clearCache: () => void;
 };

package/dist/src/beta/components/Table/base/TableBase.d.ts

@@ -1,43 +1,25 @@
 import { ComponentPropsWithoutRef } from 'react';
-/**
- * Props for the SimpleTableBase component
- * @extends ComponentPropsWithoutRef<"table">
- */
 export type SimpleTableBaseProps = ComponentPropsWithoutRef<"table">;
-/**
- * Props for the DataTableBase component
- * @extends Omit<ComponentPropsWithoutRef<"div">, "aria-colcount" | "aria-rowcount">
- */
 export type DataTableBaseProps = Omit<ComponentPropsWithoutRef<"div">, "aria-colcount" | "aria-rowcount"> & {
-    /**
-     * The number of columns in the table
-     */
+    /** Total leaf-column count exposed through `aria-colcount`. */
     colCount: number;
-    /**
-     * The number of rows in the table
-     */
+    /** Total header, body, and footer row count exposed through `aria-rowcount`. */
     rowCount: number;
-    /**
-     * Whether the table has expandable rows
-     */
+    /** Uses tree-grid semantics when rows can contain child rows. */
     hasSubRows?: boolean;
 };
 /**
- * Props for the TableBase component
- * @extends SimpleTableBaseProps
- * @extends DataTableBaseProps
+ * Selects native table markup or an ARIA grid from the corresponding prop
+ * branch.
  */
 export type TableBaseProps = ({
+    /** Renders a native `table`. */
     type: "simple";
 } & SimpleTableBaseProps) | ({
+    /** Renders a focus-managed `grid` or `treegrid`. */
     type: "data-table";
 } & DataTableBaseProps);
 /**
- * Styled table component for simple presentational or complex data tables
- * @param props - The props for the TableBase component
- * @param props.type - The type of the TableBase component
- * @param props.children - The children of the TableBase component
- * @param props.className - The class name of the TableBase component
- * @param props.ref - The ref of the TableBase component
+ * Structural root for a native table or focus-managed ARIA data grid.
  */
 export declare const TableBase: ({ type, ...rest }: TableBaseProps) => import("react/jsx-runtime").JSX.Element | undefined;

package/dist/src/beta/components/Table/base/TableBody.d.ts

@@ -1,25 +1,16 @@
 import { ComponentPropsWithoutRef } from 'react';
 /**
- * Props for the TableBody component
- * @extends ComponentPropsWithoutRef<"tbody">
- * @extends ComponentPropsWithoutRef<"div">
+ * Selects native table-body markup or an ARIA row group from the corresponding
+ * prop branch.
  */
 export type TableBodyProps = ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a native `tbody`. */
     type: "simple";
 } & ComponentPropsWithoutRef<"tbody">) | ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a `rowgroup` for an ARIA grid. */
     type: "data-table";
 } & ComponentPropsWithoutRef<"div">);
 /**
- * Table body component for simple presentational or complex data tables
- * @param props - The props for the TableBody component
- * @param props.type - The type of table being rendered
- * @param props.children - The children of the TableBody component
- * @param props.ref - The ref of the TableBody component
+ * Body region for a native table or ARIA data grid.
  */
 export declare function TableBody({ type, children, ...rest }: TableBodyProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/base/TableContainer.d.ts

@@ -1,17 +1,7 @@
 import { ComponentPropsWithoutRef } from 'react';
 import { LayoutUtilProps } from '../../../../types';
-/**
- * Props for the TableContainer component
- * @extends LayoutUtilProps
- * @extends ComponentPropsWithoutRef<"div">
- */
 export type TableContainerProps = LayoutUtilProps & ComponentPropsWithoutRef<"div">;
 /**
- * Styled container for tables that includes a scroll container and provides consistent background and border treatment
- * @param props - The props for the TableContainer component
- * @param props.children - The children of the TableContainer component
- * @param props.className - The class name of the TableContainer component
- * @param props.style - The style of the TableContainer component
- * @param props.ref - The ref of the TableContainer component
+ * Provides the table surface and an inner vertical scrolling region.
  */
 export declare const TableContainer: import('react').ForwardRefExoticComponent<LayoutUtilProps & Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/beta/components/Table/base/TableFooter.d.ts

@@ -1,25 +1,16 @@
 import { ComponentPropsWithoutRef } from 'react';
 /**
- * Props for the TableFooter component
- * @extends ComponentPropsWithoutRef<"tfoot">
- * @extends ComponentPropsWithoutRef<"div">
+ * Selects native table-footer markup or an ARIA row group from the
+ * corresponding prop branch.
  */
 export type TableFooterProps = ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a native `tfoot`. */
     type: "simple";
 } & ComponentPropsWithoutRef<"tfoot">) | ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a `rowgroup` for an ARIA grid. */
     type: "data-table";
 } & ComponentPropsWithoutRef<"div">);
 /**
- * Table footer component for simple presentational or complex data tables
- * @param props - The props for the TableFooter component
- * @param props.type - The type of table being rendered
- * @param props.children - The children of the TableFooter component
- * @param props.ref - The ref of the TableFooter component
+ * Sticky footer region for a native table or ARIA data grid.
  */
 export declare function TableFooter({ type, children, ...rest }: TableFooterProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/base/TableHeader.d.ts

@@ -1,25 +1,16 @@
 import { ComponentPropsWithoutRef } from 'react';
 /**
- * Props for the TableHeader component
- * @extends ComponentPropsWithoutRef<"thead">
- * @extends ComponentPropsWithoutRef<"div">
+ * Selects native table-header markup or an ARIA row group from the
+ * corresponding prop branch.
  */
 export type TableHeaderProps = ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a native `thead`. */
     type: "simple";
 } & ComponentPropsWithoutRef<"thead">) | ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a `rowgroup` for an ARIA grid. */
     type: "data-table";
 } & ComponentPropsWithoutRef<"div">);
 /**
- * Table header component for simple presentational or complex data tables
- * @param props - The props for the TableHeader component
- * @param props.type - The type of table being rendered
- * @param props.children - The children of the TableHeader component
- * @param props.ref - The ref of the TableHeader component
+ * Sticky header region for a native table or ARIA data grid.
  */
 export declare function TableHeader({ type, children, ...rest }: TableHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/base/cells/TableBodyCell.d.ts

@@ -3,25 +3,16 @@ import { CommonTableCellProps } from './types';
 export type SimpleTableBodyCellProps = ComponentPropsWithoutRef<"td"> & CommonTableCellProps;
 export type DataTableBodyCellProps = ComponentPropsWithoutRef<"div"> & CommonTableCellProps;
 /**
- * The props for the TableBodyCell component
+ * Selects a native or ARIA body cell from the corresponding prop branch.
  */
 export type TableBodyCellProps = ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a native `td`. */
     type: "simple";
 } & SimpleTableBodyCellProps) | ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a `gridcell` for an ARIA grid. */
     type: "data-table";
 } & DataTableBodyCellProps);
 /**
- * The styled table body cell component
- * @param props - The props for the TableBodyCell component
- * @param props.type - The type of table being rendered
- * @param props.children - The children to render in the cell
- * @param props.className - The class name of the TableBodyCell component
- * @param props.rest - The rest of the props
+ * Body cell for a native table or ARIA data grid.
  */
 export declare const TableBodyCell: import('react').ForwardRefExoticComponent<TableBodyCellProps & import('react').RefAttributes<HTMLDivElement | HTMLTableCellElement>>;

package/dist/src/beta/components/Table/base/cells/TableEmptyCellContent.d.ts

@@ -1,4 +1,4 @@
 /**
- * The empty cell content for table cells
+ * Em-dash placeholder that announces an empty table cell.
  */
 export declare const TableEmptyCellContent: () => import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/base/cells/TableFooterCell.d.ts

@@ -3,28 +3,20 @@ export type SimpleTableFooterCellProps = ComponentPropsWithoutRef<"td"> & {
     colSpan?: number;
 };
 export type DataTableFooterCellProps = ComponentPropsWithoutRef<"div"> & {
+    /** Number of logical columns represented by this footer cell. */
     colSpan?: number;
 };
 /**
- * The props for the TableFooterCell component
+ * Selects a native or ARIA footer cell from the corresponding prop branch.
  */
 export type TableFooterCellProps = ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a native `td`. */
     type: "simple";
 } & SimpleTableFooterCellProps) | ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a `gridcell` for an ARIA grid. */
     type: "data-table";
 } & DataTableFooterCellProps);
 /**
- * The styled table footer cell component
- * @param props - The props for the TableFooterCell component
- * @param props.type - The type of table being rendered
- * @param props.children - The children to render in the cell
- * @param props.className - The class name of the TableFooterCell component
- * @param props.rest - The rest of the props
+ * Footer cell for a native table or ARIA data grid.
  */
 export declare const TableFooterCell: import('react').ForwardRefExoticComponent<TableFooterCellProps & import('react').RefAttributes<HTMLDivElement | HTMLTableCellElement>>;

package/dist/src/beta/components/Table/base/cells/TableHeaderCell.d.ts

@@ -1,44 +1,27 @@
 import { ComponentPropsWithoutRef } from 'react';
 import { CommonTableCellProps } from './types';
-/**
- * The common props for the TableHeaderCell component
- */
 export type CommonTableHeaderCellProps = CommonTableCellProps & {
-    /**
-     * Whether the cell is a group cell (for grouped columns)
-     */
+    /** Shows a column-group divider except on the last cell in the row. */
     isGroup?: boolean;
-    /**
-     * Whether the header cell can be used to activate column sorting
-     */
+    /** Shows the interactive cursor for a sortable column. */
     isSortable?: boolean;
-    /**
-     * Whether the header cell should show whole-cell interactive affordances
-     */
+    /** Shows the interactive cursor when the whole header cell activates an action. */
     isInteractiveHeaderCell?: boolean;
 };
 export type SimpleTableHeaderCellProps = CommonTableHeaderCellProps & ComponentPropsWithoutRef<"th">;
 export type DataTableHeaderCellProps = CommonTableHeaderCellProps & ComponentPropsWithoutRef<"div">;
 /**
- * The props for the TableHeaderCell component
+ * Selects a native or ARIA column-header cell from the corresponding prop
+ * branch.
  */
 export type TableHeaderCellProps = ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a native `th`. */
     type: "simple";
 } & SimpleTableHeaderCellProps) | ({
-    /**
-     * The type of table being rendered
-     */
+    /** Renders a `columnheader` for an ARIA grid. */
     type: "data-table";
 } & DataTableHeaderCellProps);
 /**
- * The styled table header cell component
- * @param props - The props for the TableHeaderCell component
- * @param props.type - The type of table being rendered
- * @param props.children - The children to render in the cell
- * @param props.className - The class name of the TableHeaderCell component
- * @param props.rest - The rest of the props
+ * Header cell for a native table or ARIA data grid.
  */
 export declare const TableHeaderCell: import('react').ForwardRefExoticComponent<TableHeaderCellProps & import('react').RefAttributes<HTMLDivElement | HTMLTableCellElement>>;

package/dist/src/beta/components/Table/base/cells/types.d.ts

@@ -1,10 +1,6 @@
 export type CommonTableCellProps = {
-    /**
-     * Whether the cell is an expand cell (for expandable rows)
-     */
+    /** Applies the compact spacing reserved for row-expansion controls. */
     isExpandCell?: boolean;
-    /**
-     * Whether the cell is a select cell (for selectable rows)
-     */
+    /** Applies the centered, compact spacing reserved for selection controls. */
     isSelectCell?: boolean;
 };

package/dist/src/beta/components/Table/columnTypeDefaults.d.ts

@@ -1,51 +1,22 @@
 import { ReactNode } from 'react';
 import { ColumnType, ColumnTypeConfig, ColumnTypeOptionsMap } from './types';
 /**
- * Display defaults for a column type.
- * Defines the default formatter and alignment for each column type.
+ * Alignment and renderer factory applied when a column declares `type`.
  */
 export type ColumnTypeDefaults = {
-    /**
-     * Default horizontal alignment for the column.
-     */
+    /** Used unless the column supplies `align`. */
     align: "start" | "center" | "end";
     /**
-     * Factory function to create the default renderCell function.
-     * Receives formatter options and returns the renderCell function.
+     * Creates the default cell renderer from that type's formatter options.
+     * `undefined` leaves text values on the raw-value render path.
      */
     createRenderCell: (options?: ColumnTypeOptionsMap[ColumnType]) => ((value: unknown, rowDepth: number) => ReactNode) | undefined;
 };
 /**
- * Mapping of column types to their display defaults.
- * Used by the column helper to apply sensible defaults based on data type.
+ * Built-in formatter and alignment defaults keyed by {@link ColumnType}.
  */
 export declare const COLUMN_TYPE_DEFAULTS: Record<ColumnType, ColumnTypeDefaults>;
-/**
- * Extracts the column type string and options from a ColumnTypeConfig.
- *
- * @param config - The column type configuration (string or object)
- * @returns Tuple of [type string, options object or undefined]
- *
- * @example
- * ```ts
- * resolveColumnTypeConfig("currency")
- * // Returns: ["currency", undefined]
- *
- * resolveColumnTypeConfig({ type: "currency", options: { currency: "EUR" } })
- * // Returns: ["currency", { currency: "EUR" }]
- * ```
- */
+/** Normalizes shorthand and object column-type configurations to a tuple. */
 export declare function resolveColumnTypeConfig<T extends ColumnType>(config: ColumnTypeConfig<T>): [T, ColumnTypeOptionsMap[T] | undefined];
-/**
- * Gets the display defaults for a column type.
- *
- * @param type - The column type
- * @returns The column type defaults (align and createRenderCell)
- *
- * @example
- * ```ts
- * const defaults = getColumnTypeDefaults("currency");
- * // Returns: { align: "end", createRenderCell: ... }
- * ```
- */
+/** Returns the built-in display defaults for a column type. */
 export declare function getColumnTypeDefaults(type: ColumnType): ColumnTypeDefaults;