@servicetitan/anvil2 3.0.6 → 3.0.8

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

@@ -53,9 +53,12 @@ export type DataTableCacheOptions = {
     maxSize?: number;
 };
 /**
- * Configuration for pagination in DataTable
+ * Pagination behavior for DataTable.
+ * "offset" uses numbered pages with a known total row count.
+ * "cursor" uses previous/next availability for unknown-total pagination.
  */
-export type DataTablePaginationConfig<T> = {
+export type DataTablePaginationMode = "offset" | "cursor";
+type DataTablePaginationBaseConfig<T> = {
     /**
      * Number of rows displayed per page
      * @default 25
@@ -96,28 +99,57 @@ export type DataTablePaginationConfig<T> = {
      * Callback when page changes. Receives the new page index (0-based)
      */
     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.
+     */
+    refreshKey?: string | number;
+    /**
+     * Configuration for caching loadPageData results.
+     * Caching is enabled by default. Set `{ enabled: false }` to disable.
+     */
+    cache?: DataTableCacheOptions;
+};
+export type DataTableOffsetPaginationConfig<T> = DataTablePaginationBaseConfig<T> & {
+    /**
+     * Offset pagination mode.
+     * @default "offset"
+     */
+    mode?: "offset";
     /**
      * Whether to display the item count information in pagination
      * @default true
      */
     showCount?: boolean;
     /**
-     * Total number of rows across all pages. Falls back to data.length if not provided.
+     * 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.
      */
     totalRowCount?: number;
+    hasNextPage?: never;
+    hasPrevPage?: never;
+};
+export type DataTableCursorPaginationConfig<T> = DataTablePaginationBaseConfig<T> & {
     /**
-     * Key that triggers data refetch when changed.
-     * Useful for forcing refetch when external filters change.
-     * When changed, the page index automatically resets to 0.
+     * Cursor pagination mode for datasets where the total row count is unknown.
      */
-    refreshKey?: string | number;
+    mode: "cursor";
     /**
-     * Configuration for caching loadPageData results.
-     * Caching is enabled by default. Set `{ enabled: false }` to disable.
+     * Whether another page is available.
      */
-    cache?: DataTableCacheOptions;
+    hasNextPage: boolean;
+    /**
+     * Whether a previous page is available.
+     */
+    hasPrevPage: boolean;
+    showCount?: never;
+    totalRowCount?: never;
 };
+/**
+ * Configuration for pagination in DataTable
+ */
+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).
@@ -135,3 +167,4 @@ export type DataTableRef = {
      */
     clearCache: () => void;
 };
+export {};

package/dist/src/beta/components/Toolbar/internal/ToolbarContext.d.ts

@@ -25,9 +25,10 @@ export type ToolbarContextProps = {
      */
     orderedIds?: string[];
     /**
-     * Overflow behavior type (wrap or collapse)
+     * Overflow behavior type. Defaults to wrap behavior when omitted.
+     * @default "wrap"
      */
-    overflow: ToolbarOverflowTypes;
+    overflow?: ToolbarOverflowTypes;
     /**
      * Size of toolbar child components
      */

package/dist/src/beta/components/TreeSelectField/TreeSelectField.d.ts

@@ -0,0 +1,68 @@
+import { TreeSelectFieldHandle, TreeSelectFieldNode } from './types';
+/**
+ * TreeSelectField component for selecting one or more nodes from a hierarchical tree structure.
+ *
+ * Features:
+ * - Async tree data loading via loadOptions callback with optional LRU caching
+ * - Single-select and multi-select modes
+ * - Multi-select chips display with optional singleRow and maxChips limits
+ * - Search filtering that preserves tree structure
+ * - Cascading parent/child selection (linked mode) or independent node selection
+ * - Lazy branch expansion with on-demand children loading
+ * - Virtualized rendering for large trees via the virtualize prop
+ * - Full keyboard navigation (ArrowDown/Up, ArrowRight/Left, Enter, Home/End, Escape, Backspace)
+ * - Imperative handle for clearCache, invalidate, expandAll, collapseAll
+ * - Accessible label, error, hint, description, and warning helper text
+ * - Prefix and suffix slot support
+ * - Supports layout utilities for positioning and spacing
+ *
+ * @example
+ * <TreeSelectField
+ *   label="Select Categories"
+ *   value={selected}
+ *   onSelectedOptionsChange={setSelected}
+ *   loadOptions={async (search) => fetchCategories(search)}
+ * />
+ */
+export declare const TreeSelectField: import('react').ForwardRefExoticComponent<{
+    id?: string;
+    label: string;
+    labelNode?: import('react').ReactNode;
+    hideLabel?: boolean;
+    placeholder?: string;
+    size?: Extract<import('../../..').Size, "small" | "medium" | "large">;
+    displayMenuAs?: "auto" | "popover" | "dialog";
+    error?: boolean | string | string[] | import('react').ReactElement;
+    hint?: import('react').ReactElement | string;
+    moreInfo?: import('react').ReactNode;
+    labelAiMark?: import('../../..').AiMarkWithTooltipOrPopoverProps["aiMark"];
+    description?: import('react').ReactElement | string;
+    warning?: string | string[];
+    required?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    prefix?: string | import('react').ReactElement;
+    suffix?: string | import('react').ReactElement;
+    className?: string;
+    style?: import('react').CSSProperties;
+    disableSearch?: boolean;
+    debounceMs?: number;
+    searchValue?: string;
+    onSearchChange?: (v: string) => void;
+    singleRow?: boolean;
+    maxChips?: number;
+    virtualize?: boolean;
+    value: import('./types').TreeSelectFieldValue[];
+    onSelectedOptionsChange: (nodes: import('./types').TreeSelectFieldValue[]) => void;
+    selectionMode?: "single" | "independent" | "linked";
+    valueConsistsOf?: import('./types').TreeSelectFieldValueConsistsOf;
+    defaultExpandLevel?: number;
+    expandedIds?: Set<string | number>;
+    onExpandedIdsChange?: (ids: Set<string | number>) => void;
+    loadOptions: (searchValue: string, parentNode?: TreeSelectFieldNode) => TreeSelectFieldNode[] | Promise<TreeSelectFieldNode[]>;
+    cache?: {
+        enabled?: boolean;
+        maxSize?: number;
+    };
+    initialLoad?: "auto" | "immediate" | "open";
+} & import('../../..').LayoutUtilProps & import('react').RefAttributes<TreeSelectFieldHandle>>;

package/dist/src/beta/components/TreeSelectField/TreeSelectFieldSync.d.ts

@@ -0,0 +1,64 @@
+import { MatchSorterOptions } from 'match-sorter';
+import { TreeSelectFieldNode, TreeSelectFieldProps } from './types';
+import { TreeSyncFilterFn } from './internal/treeSync';
+export type { TreeSyncFilterFn };
+/**
+ * Props for the TreeSelectFieldSync component.
+ * @property options - The static tree options to display.
+ * @property filter - Custom filter function or MatchSorterOptions to control how nodes are filtered during search.
+ *   By default, filters by label and searchText using match-sorter, preserving parent nodes of any match.
+ * @extends TreeSelectFieldProps
+ */
+export type TreeSelectFieldSyncProps = Omit<TreeSelectFieldProps, "loadOptions" | "debounceMs" | "cache" | "initialLoad"> & {
+    /**
+     * The static tree options to display in the field.
+     */
+    options: TreeSelectFieldNode[];
+    /**
+     * Controls how options are filtered when the user types a search value.
+     * Can be a function that returns nodes in the desired display order,
+     * or a MatchSorterOptions object to customize the default match-sorter behavior.
+     *
+     * By default, nodes are filtered by `label` and `searchText` using match-sorter,
+     * and parents of matching nodes are preserved in the tree structure.
+     *
+     * @example
+     * <TreeSelectFieldSync
+     *   options={options}
+     *   filter={(nodes, searchValue) => {
+     *     return nodes.filter((node) =>
+     *       node.label.toLowerCase().includes(searchValue.toLowerCase())
+     *     );
+     *   }}
+     * />
+     *
+     * @example
+     * <TreeSelectFieldSync
+     *   options={options}
+     *   filter={{ keys: ["label"] }}
+     * />
+     */
+    filter?: TreeSyncFilterFn | MatchSorterOptions<TreeSelectFieldNode>;
+};
+/**
+ * TreeSelectFieldSync is a simplified wrapper around TreeSelectField for static (non-async) tree data.
+ *
+ * Features:
+ * - Accepts static `options` instead of `loadOptions`.
+ * - Performs client-side filtering with tree-structure awareness (parents of matches are preserved).
+ * - Accepts a custom filter function or MatchSorterOptions to customize filtering behavior.
+ * - Invalidates the field when the options reference changes.
+ * - Supports all other props of TreeSelectField.
+ *
+ * @example
+ * <TreeSelectFieldSync
+ *   label="Select location"
+ *   options={locationTree}
+ *   value={selected}
+ *   onSelectedOptionsChange={setSelected}
+ * />
+ */
+export declare const TreeSelectFieldSync: {
+    (props: TreeSelectFieldSyncProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,3 @@
+export { TreeSelectField } from './TreeSelectField';
+export { TreeSelectFieldSync } from './TreeSelectFieldSync';
+export * from './types';

package/dist/src/beta/components/TreeSelectField/internal/TreeContent.d.ts

@@ -0,0 +1,31 @@
+import { TreePanelProps } from './TreePanel';
+/**
+ * Props for the TreeContent component.
+ *
+ * @property loading - Whether the tree is currently loading data; renders a spinner while true.
+ * @property hasNoVisibleNodes - True when there are no nodes to render (e.g. a search returned no matches); renders an empty-state message.
+ * @property virtualize - When true, renders the virtualized panel; otherwise renders the standard panel.
+ * @property panelProps - Props forwarded to the underlying TreePanel or VirtualizedTreePanel.
+ */
+export type TreeContentProps = {
+    loading: boolean;
+    hasNoVisibleNodes: boolean;
+    virtualize?: boolean;
+    panelProps: TreePanelProps;
+};
+/**
+ * Renders the body of a tree select popover or dialog: a centered spinner
+ * while loading, a "No match found" message when there are no visible
+ * nodes, or the (optionally virtualized) tree panel.
+ *
+ * Used by both TreeSelectField and TreeSelectMenu to keep the three
+ * states consistent across the field's dialog and popover branches and
+ * the menu's render path.
+ *
+ * Features:
+ * - Centered medium Spinner while loading
+ * - "No match found" empty state (small, subdued text)
+ * - Switches between TreePanel and VirtualizedTreePanel via the `virtualize` flag
+ * - Forwards a ref to the underlying tree panel for focus management
+ */
+export declare const TreeContent: import('react').ForwardRefExoticComponent<TreeContentProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/beta/components/TreeSelectField/internal/TreePanel.d.ts

@@ -0,0 +1,56 @@
+import { TreeSelectFieldNode } from '../types';
+import { VisibleNode } from './types';
+/**
+ * Props for the TreePanel component.
+ * @property {VisibleNode[]} visibleNodes - Flat list of nodes currently visible in the tree.
+ * @property {(id: string | number) => "checked" | "unchecked" | "indeterminate" | "loading"} getCheckState - Returns the check state for a given node id.
+ * @property {(id: string | number) => void} toggleNode - Toggles the selection state of a node.
+ * @property {(id: string | number) => void} toggleExpand - Toggles the expanded state of a branch node.
+ * @property {(id: string | number) => Record<string, unknown>} getTreeItemProps - Returns ARIA/accessibility props for a tree item.
+ * @property {Record<string, unknown>} treeProps - Props to spread onto the tree container element.
+ * @property {string | undefined} activeDescendantId - The id of the currently active/focused tree item.
+ * @property {boolean} [branchesSelectable] - When true, branch nodes can be selected.
+ * @property {boolean} [leavesSelectable] - When true, leaf nodes can be selected.
+ * @property {boolean} [emptyBranchesSelectable] - When true, empty branches can be selected.
+ * @property {(node: TreeSelectFieldNode) => void} [onLoadChildren] - Callback to trigger lazy loading of children.
+ */
+export type TreePanelProps = {
+    visibleNodes: VisibleNode[];
+    getCheckState: (id: string | number) => "checked" | "unchecked" | "indeterminate" | "loading";
+    toggleNode: (id: string | number) => void;
+    toggleExpand: (id: string | number) => void;
+    getTreeItemProps: (id: string | number) => Record<string, unknown>;
+    treeProps: Record<string, unknown>;
+    activeDescendantId: string | undefined;
+    branchesSelectable?: boolean;
+    leavesSelectable?: boolean;
+    emptyBranchesSelectable?: boolean;
+    readOnly?: boolean;
+    onHover?: (id: string | number) => void;
+    onLoadChildren?: (node: TreeSelectFieldNode) => void;
+};
+/**
+ * TreePanel component that renders the tree dropdown content.
+ *
+ * Features:
+ * - Renders a flat list of visible nodes with depth-based indentation
+ * - Supports expand/collapse controls for branch nodes
+ * - Shows loading indicator for lazily-loaded branches
+ * - Checkboxes for multi-select mode (hidden in single-select mode)
+ * - Optional breadcrumb display for flattened search results
+ * - Optional child count display for branch nodes
+ * - Full accessibility support with ARIA tree/treeitem roles
+ * - Focusable container via forwardRef
+ *
+ * @example
+ * <TreePanel
+ *   visibleNodes={visibleNodes}
+ *   getCheckState={getCheckState}
+ *   toggleNode={toggleNode}
+ *   toggleExpand={toggleExpand}
+ *   getTreeItemProps={getTreeItemProps}
+ *   treeProps={treeProps}
+ *   activeDescendantId={activeDescendantId}
+ * />
+ */
+export declare const TreePanel: import('react').ForwardRefExoticComponent<TreePanelProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/beta/components/TreeSelectField/internal/TreeRow.d.ts

@@ -0,0 +1,56 @@
+import { TreeSelectFieldNode } from '../types';
+import { VisibleNode } from './types';
+/**
+ * Props for the TreeRow component.
+ * @property {VisibleNode} visible - The visible node data including depth, expand state, and branch info.
+ * @property {"checked" | "unchecked" | "indeterminate"} checkState - The checkbox state for this row.
+ * @property {Record<string, unknown>} itemProps - ARIA/accessibility props from getTreeItemProps.
+ * @property {boolean} [branchesSelectable] - When true, branch nodes can be selected. Defaults to true.
+ * @property {boolean} [leavesSelectable] - When true, leaf nodes can be selected. Defaults to true.
+ * @property {boolean} [emptyBranchesSelectable] - When true, empty branches (children: []) can be selected. Defaults to true.
+ * @property {boolean} [isActive] - When true, applies a highlight background for keyboard focus.
+ * @property {(id: string | number) => void} onToggleNode - Callback to toggle selection of the node.
+ * @property {(id: string | number) => void} onToggleExpand - Callback to toggle expansion of a branch node.
+ * @property {(node: TreeSelectFieldNode) => void} [onLoadChildren] - Callback to trigger lazy loading of children.
+ * @property {number} depth - Depth of the node in the tree, used to calculate indentation.
+ */
+export type TreeRowProps = {
+    visible: VisibleNode;
+    checkState: "checked" | "unchecked" | "indeterminate" | "loading";
+    itemProps: Record<string, unknown>;
+    branchesSelectable?: boolean;
+    leavesSelectable?: boolean;
+    emptyBranchesSelectable?: boolean;
+    readOnly?: boolean;
+    isActive?: boolean;
+    onToggleNode: (id: string | number) => void;
+    onToggleExpand: (id: string | number) => void;
+    onHover?: (id: string | number) => void;
+    onLoadChildren?: (node: TreeSelectFieldNode) => void;
+    depth: number;
+};
+/**
+ * TreeRow renders a single row in the tree dropdown.
+ *
+ * Features:
+ * - Depth-based indentation via inline paddingInlineStart
+ * - Expand/collapse icon using Icon component with keyboard_arrow_right/down icons
+ * - Spinning icon animation for lazy-loading branch nodes
+ * - Checkbox in multi-select mode, hidden in single-select mode
+ * - Rich content support via node.content (title, description, chips, avatar, icon)
+ * - Label text with overflow ellipsis
+ * - Disabled state with reduced opacity and default cursor
+ * - Active (keyboard focus) state with highlight background
+ * - Full ARIA semantics via spread itemProps
+ *
+ * @example
+ * <TreeRow
+ *   visible={visibleNode}
+ *   checkState={getCheckState(visibleNode.node.id)}
+ *   itemProps={getTreeItemProps(visibleNode.node.id)}
+ *   onToggleNode={toggleNode}
+ *   onToggleExpand={toggleExpand}
+ *   depth={visibleNode.depth}
+ * />
+ */
+export declare function TreeRow({ visible, checkState, itemProps, branchesSelectable, leavesSelectable, emptyBranchesSelectable, readOnly, isActive, onToggleNode, onToggleExpand, onHover, onLoadChildren, depth, }: TreeRowProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/TreeSelectField/internal/TreeSelectFieldInput.d.ts

@@ -0,0 +1,82 @@
+import { ReactElement, RefObject } from 'react';
+import { TreeSelectFieldValue } from '../types';
+/**
+ * Props for the TreeSelectFieldInput component.
+ * @property {string} [id] - HTML id attribute for the input element
+ * @property {string} [placeholder] - Placeholder text displayed when no options are selected
+ * @property {"small" | "medium" | "large"} [size] - Size variant of the input
+ * @property {boolean} [disabled] - Disables the input entirely
+ * @property {boolean} [readOnly] - Cannot be modified but remains interactive
+ * @property {boolean} [error] - Shows error styling on the input when true
+ * @property {boolean} [single] - When true, renders single-select text display instead of chips
+ * @property {boolean} [singleRow] - When true, restricts chip display to a single row
+ * @property {number} [maxChips] - Maximum number of chips to display before showing +N indicator
+ * @property {string | ReactElement} [prefix] - Content to display before the input area
+ * @property {string | ReactElement} [suffix] - Content to display after the input area
+ * @property {TreeSelectFieldValue[]} selectedOptions - Array of currently selected options
+ * @property {(option: TreeSelectFieldValue) => void} onRemoveOption - Callback fired when a chip is removed
+ * @property {RefObject<HTMLInputElement>} [inputRef] - Ref for the input element
+ * @property {RefObject<HTMLDivElement>} [inputWrapperRef] - Ref for the input wrapper div element
+ * @property {string} [searchValue] - Current search input value
+ * @property {(e: React.ChangeEvent<HTMLInputElement>) => void} [onSearchChange] - Callback fired when search input changes
+ * @property {(e: React.KeyboardEvent) => void} [onInputKeyDown] - Callback fired on key down in the search input
+ * @property {() => void} [onWrapperClick] - Callback fired when the input wrapper is clicked
+ * @property {boolean} [isOpen] - Whether the dropdown is currently open
+ * @property {boolean} [disableSearch] - When true, hides the search input
+ * @property {Record<string, unknown>} [comboboxProps] - Additional ARIA props for the combobox input role
+ */
+export type TreeSelectFieldInputProps = {
+    id?: string;
+    placeholder?: string;
+    size?: "small" | "medium" | "large";
+    disabled?: boolean;
+    readOnly?: boolean;
+    error?: boolean;
+    single?: boolean;
+    singleRow?: boolean;
+    maxChips?: number;
+    prefix?: string | ReactElement;
+    suffix?: string | ReactElement;
+    selectedOptions: TreeSelectFieldValue[];
+    onRemoveOption: (option: TreeSelectFieldValue) => void;
+    inputRef?: RefObject<HTMLInputElement>;
+    inputWrapperRef?: RefObject<HTMLDivElement>;
+    searchValue?: string;
+    onSearchChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onInputKeyDown?: (e: React.KeyboardEvent) => void;
+    onWrapperClick?: () => void;
+    isOpen?: boolean;
+    ariaControls?: string;
+    disableSearch?: boolean;
+    comboboxProps?: Record<string, unknown>;
+};
+/**
+ * Internal input component for the TreeSelectField that renders the trigger area
+ * with chips, search input, single-select text, and the toggle button.
+ *
+ * Features:
+ * - Chip display for selected options in multi-select mode with remove functionality
+ * - Single-row chip overflow detection with +N hidden chip indicator
+ * - Text input for filtering tree options when search is enabled
+ * - Plain text display for single-select mode
+ * - Chevron toggle button to open/close the dropdown
+ * - Optional prefix and suffix content slots
+ * - Supports small, medium, and large size variants
+ * - Error state styling
+ * - Disabled and read-only state styling
+ * - Accessible combobox role with aria-expanded and aria-haspopup
+ *
+ * @example
+ * <TreeSelectFieldInput
+ *   placeholder="Select categories..."
+ *   size="medium"
+ *   selectedOptions={[{ id: 1, label: "Category A" }]}
+ *   onRemoveOption={(option) => handleRemove(option)}
+ *   isOpen={isOpen}
+ *   onWrapperClick={() => setIsOpen(true)}
+ * />
+ */
+export declare const TreeSelectFieldInput: {
+    ({ id, placeholder, size, disabled, readOnly, error, single, singleRow, maxChips, prefix, suffix, selectedOptions, onRemoveOption, inputRef, inputWrapperRef, searchValue, onSearchChange, onInputKeyDown, onWrapperClick, isOpen, ariaControls, disableSearch, comboboxProps, }: TreeSelectFieldInputProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/beta/components/TreeSelectField/internal/VirtualizedTreePanel.d.ts

@@ -0,0 +1,57 @@
+import { TreeSelectFieldNode } from '../types';
+import { VisibleNode } from './types';
+/**
+ * Props for the VirtualizedTreePanel component.
+ * @property visibleNodes - Flat list of currently visible tree nodes.
+ * @property getCheckState - Returns the visual check state for a node ID.
+ * @property toggleNode - Toggles selection for the given node ID.
+ * @property toggleExpand - Expands or collapses the given branch node ID.
+ * @property getTreeItemProps - Returns ARIA props for a given node ID.
+ * @property treeProps - ARIA props for the tree container element.
+ * @property activeDescendantId - The id attribute of the focused treeitem, for aria-activedescendant.
+ * @property branchesSelectable - When true, branch nodes can be selected.
+ * @property leavesSelectable - When true, leaf nodes can be selected.
+ * @property onLoadChildren - Callback to lazily load children for a node with children===null.
+ */
+export type VirtualizedTreePanelProps = {
+    visibleNodes: VisibleNode[];
+    getCheckState: (id: string | number) => "checked" | "unchecked" | "indeterminate" | "loading";
+    toggleNode: (id: string | number) => void;
+    toggleExpand: (id: string | number) => void;
+    getTreeItemProps: (id: string | number) => Record<string, unknown>;
+    treeProps: Record<string, unknown>;
+    activeDescendantId: string | undefined;
+    branchesSelectable?: boolean;
+    leavesSelectable?: boolean;
+    emptyBranchesSelectable?: boolean;
+    readOnly?: boolean;
+    onHover?: (id: string | number) => void;
+    onLoadChildren?: (node: TreeSelectFieldNode) => void;
+};
+/**
+ * VirtualizedTreePanel renders a virtualized tree list using @tanstack/react-virtual,
+ * only mounting DOM nodes for visible rows. Intended for large tree datasets.
+ *
+ * Features:
+ * - Only renders visible rows via @tanstack/react-virtual for performance
+ * - Same visual output and interaction model as a non-virtualized tree panel
+ * - Supports multi-select checkboxes and single-select modes
+ * - Expand/collapse branch nodes with optional lazy loading
+ * - Keyboard navigation via onKeyDown handler
+ * - Full ARIA tree semantics (role, aria-level, aria-expanded, etc.)
+ * - Optional child count display on branch nodes
+ * - Breadcrumb display for flattened search results
+ *
+ * @example
+ * <VirtualizedTreePanel
+ *   visibleNodes={visibleNodes}
+ *   getCheckState={getCheckState}
+ *   toggleNode={toggleNode}
+ *   toggleExpand={toggleExpand}
+ *   getTreeItemProps={getTreeItemProps}
+ *   treeProps={treeProps}
+ *   onKeyDown={onKeyDown}
+ *   activeDescendantId={activeDescendantId}
+ * />
+ */
+export declare const VirtualizedTreePanel: import('react').ForwardRefExoticComponent<VirtualizedTreePanelProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/beta/components/TreeSelectField/internal/treeSync.d.ts

@@ -0,0 +1,33 @@
+import { MatchSorterOptions } from 'match-sorter';
+import { TreeSelectFieldNode } from '../types';
+/**
+ * Filter function for narrowing tree options against a search value.
+ * Receives the full options tree and returns the (possibly pruned) tree to display.
+ */
+export type TreeSyncFilterFn = (options: TreeSelectFieldNode[], searchValue: string) => TreeSelectFieldNode[];
+/**
+ * Recursively populates `childCount` (number of immediate children) on every
+ * loaded branch that doesn't already declare one, returning a new tree.
+ *
+ * This is computed from the full static `options` *before* any search filter
+ * runs, so the count reflects the real child set rather than the filtered
+ * subset. `computeCheckStates` relies on `childCount` to detect that a branch
+ * is only partially represented (e.g. during search) and avoid showing a
+ * partially-selected branch as fully checked.
+ *
+ * @param nodes - The tree nodes to process.
+ * @returns A new array of nodes with childCount set on branch nodes.
+ */
+export declare function applyChildCounts(nodes: TreeSelectFieldNode[]): TreeSelectFieldNode[];
+/**
+ * Default tree-aware filter. Matches on label and searchText, preserving
+ * ancestors of matched nodes.
+ */
+export declare function defaultTreeSyncFilter(nodes: TreeSelectFieldNode[], searchValue: string): TreeSelectFieldNode[];
+/**
+ * Coerces a `TreeSyncFilterFn` or `MatchSorterOptions` into a
+ * `TreeSyncFilterFn`. When given options, the resulting filter flattens the
+ * tree, runs match-sorter, and prunes the original tree to keep ancestors of
+ * matched nodes.
+ */
+export declare function toTreeSyncFilterFn(filter: TreeSyncFilterFn | MatchSorterOptions<TreeSelectFieldNode>): TreeSyncFilterFn;

package/dist/src/beta/components/TreeSelectField/internal/treeUtils.d.ts

@@ -0,0 +1,25 @@
+import { TreeSelectFieldNode } from '../types';
+/**
+ * Recursively finds the first node in the tree matching the given id.
+ *
+ * @param nodes - The tree nodes to search.
+ * @param id - The id of the node to find.
+ * @returns The matching node, or undefined if no node has the given id.
+ */
+export declare function findNode(nodes: TreeSelectFieldNode[], id: string | number): TreeSelectFieldNode | undefined;
+/**
+ * Returns true when the given node or any of its descendants still need to
+ * be lazy-loaded (i.e. has `children: null`).
+ *
+ * @param node - The node to inspect.
+ * @returns Whether any descendant branch is still unloaded.
+ */
+export declare function hasUnloadedDescendants(node: TreeSelectFieldNode): boolean;
+/**
+ * Returns all descendant branches of the given node whose children have not
+ * yet been loaded (i.e. `children: null`). The node itself is not included.
+ *
+ * @param node - The ancestor node to walk.
+ * @returns Every descendant branch that still requires lazy loading.
+ */
+export declare function findUnloadedDescendants(node: TreeSelectFieldNode): TreeSelectFieldNode[];

package/dist/src/beta/components/TreeSelectField/internal/types.d.ts

@@ -0,0 +1,12 @@
+import { TreeSelectFieldNode } from '../types';
+/**
+ * Internal representation of a visible node in the flattened tree.
+ */
+export type VisibleNode = {
+    node: TreeSelectFieldNode;
+    depth: number;
+    isExpanded: boolean;
+    isBranch: boolean;
+    isLoading: boolean;
+    isEmptyPlaceholder?: boolean;
+};