@servicetitan/anvil2 3.14.0 → 3.15.0

package/dist/src/components/Dialog/internal/useInitialFocus.d.ts

@@ -1,19 +1,8 @@
 import { RefObject } from 'react';
 import { FocusableElement } from 'tabbable';
 export type InitialFocusOptions = {
-    /**
-     * Function to pick the initial focus target, given an array of focusable elements
-     */
+    /** Selects a target from the dialog's tabbable elements. */
     computeFocus?: (focusables: FocusableElement[]) => FocusableElement;
 };
-/**
- * Hook to set initial focus for a dialog (e.g. Dialog, Drawer) when it is opened.
- * @param dialogRef - Ref to the dialog element
- * @param options - Options for the hook
- * @param options.computeFocus - Function to pick the initial focus target, given an array of focusable elements
- */
-export declare const useInitialFocus: (
-/**
- * Ref to the dialog element
- */
-dialogRef: RefObject<HTMLDialogElement>, { computeFocus }: InitialFocusOptions) => void;
+/** Moves focus into a dialog when its native `open` attribute is set. */
+export declare const useInitialFocus: (dialogRef: RefObject<HTMLDialogElement>, { computeFocus }: InitialFocusOptions) => void;

package/dist/src/components/Divider/Divider.d.ts

@@ -1,58 +1,22 @@
 import { ComponentPropsWithoutRef } from 'react';
 import { LayoutUtilProps } from '../../types';
-/**
- * Props for the Divider component
- * @extends ComponentPropsWithoutRef<"span">
- * @extends LayoutUtilProps
- */
 export type DividerProps = ComponentPropsWithoutRef<"span"> & LayoutUtilProps & {
-    /**
-     * Controls the alignment of content within the divider.
-     * @default center
-     */
+    /** Positions children at the start, center, or end. Defaults to `center`. */
     alignContent?: "start" | "center" | "end";
-    /**
-     * Controls the spacing around the divider.
-     * @default "0"
-     */
+    /** Adds space on the axis perpendicular to the divider. Defaults to `0`. */
     spacing?: "0" | "half" | "1" | "2" | "3" | "4" | "5" | "6" | "8" | "12" | 0 | 0.5 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 12;
-    /**
-     * When true, renders the divider vertically instead of horizontally.
-     * @default false
-     */
+    /** Switches the separator and spacing axis to vertical. Defaults to horizontal. */
     vertical?: boolean;
 };
 /**
- * Divider component for creating visual separators between content sections.
- *
- * Features:
- * - Horizontal and vertical divider orientations
- * - Optional content display within the divider
- * - Three content alignment options (start, center, end)
- * - Configurable spacing with predefined size tokens
- * - Supports layout utilities for positioning and spacing
- * - Flexible content placement with automatic line positioning
- * - Responsive design that adapts to container width
- *
- * @example
- * <Divider spacing="2" alignContent="center">
- *   <b>Section Title</b>
- * </Divider>
+ * Visual separator that can include aligned content and switch between
+ * horizontal and vertical orientations.
  */
 export declare const Divider: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & LayoutUtilProps & {
-    /**
-     * Controls the alignment of content within the divider.
-     * @default center
-     */
+    /** Positions children at the start, center, or end. Defaults to `center`. */
     alignContent?: "start" | "center" | "end";
-    /**
-     * Controls the spacing around the divider.
-     * @default "0"
-     */
+    /** Adds space on the axis perpendicular to the divider. Defaults to `0`. */
     spacing?: "0" | "half" | "1" | "2" | "3" | "4" | "5" | "6" | "8" | "12" | 0 | 0.5 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 12;
-    /**
-     * When true, renders the divider vertically instead of horizontally.
-     * @default false
-     */
+    /** Switches the separator and spacing axis to vertical. Defaults to horizontal. */
     vertical?: boolean;
 } & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/src/components/Dnd/DndHandle.d.ts

@@ -1,25 +1,8 @@
-/**
- * Props for the DndHandle component
- */
 export type DndHandleProps = {
-    /**
-     * Additional CSS class names to apply to the drag handle.
-     */
     className?: string;
 };
 /**
- * A reusable drag handle icon component for drag and drop interactions.
- *
- * Features:
- * - Standardized drag indicator icon
- * - Accessible with proper ARIA attributes
- * - Customizable styling through className prop
- * - Consistent visual appearance across applications
- * - Lightweight and performant
- * - Supports all standard HTML element props
- *
- * @example
- * <DndHandle className="custom-drag-handle" />
+ * Decorative drag-indicator icon for use inside a drag handle.
  */
 export declare function DndHandle({ className }: {
     className?: string;

package/dist/src/components/Dnd/DndHandleButton.d.ts

@@ -1,33 +1,9 @@
 import { ButtonCompound } from '../ButtonCompound';
-/**
- * Props for the DndHandleButton component
- * @extends React.ComponentPropsWithoutRef<typeof ButtonCompound>
- */
 export interface DndHandleButtonProps extends React.ComponentPropsWithoutRef<typeof ButtonCompound> {
-    /**
-     * Indicates whether the handle is currently being dragged.
-     * @default false
-     */
+    /** Uses the grabbing cursor while the handle is active. Defaults to `false`. */
     isActive?: boolean;
 }
 /**
- * A reusable drag handle button component for drag and drop functionality.
- *
- * Features:
- * - Interactive button with drag handle icon
- * - Visual feedback for active drag state
- * - Accessible with proper ARIA attributes (defaults to "Drag handle")
- * - Extends ButtonCompound functionality
- * - Customizable styling through className prop
- * - Supports all standard button props
- * - Consistent visual appearance across applications
- *
- * @example
- * <DndHandleButton
- *   isActive={isDragging}
- *   aria-label="Drag task item"
- *   className="custom-handle-button"
- *   onClick={handleClick}
- * />
+ * Button-style drag handle with a default accessible name of `Drag handle`.
  */
 export declare const DndHandleButton: import('react').ForwardRefExoticComponent<DndHandleButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/src/components/Dnd/DndSortLine.d.ts

@@ -1,39 +1,12 @@
-/**
- * Props for the DndSortLine component
- * @extends React.ComponentPropsWithoutRef<"div">
- */
 export type SortLineProps = React.ComponentPropsWithoutRef<"div"> & {
-    /**
-     * The offset of the line from the item. This is a CSS value, typically negative.
-     */
+    /** CSS length that offsets the line from the selected edge. Typically negative. */
     offset: string;
-    /**
-     * The orientation of the sort - Note this may be counterintuitive, as the line is rendered perpendicular to the sort.
-     */
+    /** Sort axis; the line renders perpendicular to it. */
     orientation: "horizontal" | "vertical";
-    /**
-     * The position of the line relative to a target item.
-     */
+    /** Places the line at the target item's leading or trailing edge. */
     position: "before" | "after";
 };
 /**
- * A visual indicator line that shows where an item will be dropped during drag and drop operations.
- *
- * Features:
- * - Visual feedback for drop positioning
- * - Configurable orientation (horizontal/vertical)
- * - Adjustable positioning (before/after)
- * - Customizable offset for precise placement
- * - Accessible with proper ARIA attributes
- * - Automatic CSS class management
- * - Supports all standard HTML div props
- *
- * @example
- * <DndSortLine
- *   offset="-10px"
- *   orientation="vertical"
- *   position="after"
- *   className="custom-drop-line"
- * />
+ * Decorative insertion marker positioned before or after a sortable item.
  */
 export declare const DndSortLine: ({ offset, orientation, position, ...rest }: SortLineProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Dnd/DndZone.d.ts

@@ -1,55 +1,18 @@
 import { ElementType, ReactNode } from 'react';
-/**
- * Props for the DndZone component
- * @extends Omit<React.ComponentPropsWithoutRef<T>, "el" | "ref">
- */
 export type DndZoneProps<T extends ElementType = "div"> = {
-    /**
-     * The HTML element type to render. Can be any valid HTML element or React component.
-     * @default "div"
-     */
+    /** Element or component used for the root. Defaults to `div`. */
     el?: T;
-    /**
-     * The content to be rendered inside the drop zone.
-     */
     children?: ReactNode;
-    /**
-     * Additional CSS class names to apply to the drop zone.
-     */
     className?: string;
-    /**
-     * Indicates whether a draggable item is currently over this drop zone.
-     */
+    /** Shows over feedback only while a drag is active. */
     isOver: boolean;
-    /**
-     * Indicates whether the current drag operation is valid for this drop zone.
-     */
+    /** Selects valid or invalid feedback while the current drag is over the zone. */
     isValid: boolean;
-    /**
-     * Indicates whether any item is currently being dragged.
-     */
+    /** Enables visual feedback for the current drag operation. */
     isDragging: boolean;
 } & Omit<React.ComponentPropsWithoutRef<T>, "el" | "ref">;
 /**
- * Base styling component for drop zones that handles visual states and styling.
- *
- * Features:
- * - Configurable HTML element rendering with the 'el' prop
- * - Visual feedback for drag states (over, valid, dragging)
- * - Automatic CSS class management based on drag state
- * - Supports all standard HTML element props
- * - Accessible with proper ARIA attributes
- * - Flexible styling through className prop
- * - Responsive design that adapts to container
- *
- * @example
- * <DndZone
- *   isOver={isOver}
- *   isValid={isValid}
- *   isDragging={isDragging}
- *   className="custom-drop-zone"
- * >
- *   Drop items here
- * </DndZone>
+ * Polymorphic container that renders visual feedback from externally managed
+ * drag state.
  */
 export declare const DndZone: import('react').ForwardRefExoticComponent<Omit<DndZoneProps<ElementType>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/components/Dnd/index.d.ts

@@ -1,7 +1,15 @@
 import { DndHandle } from './DndHandle';
+/**
+ * Presentational primitives for drag handles, insertion markers, and
+ * externally managed drop-zone states.
+ */
 export declare const Dnd: {
+    /** Decorative drag-indicator icon. */
     Handle: typeof DndHandle;
+    /** Button-style drag handle. */
     HandleButton: import('react').ForwardRefExoticComponent<import('./DndHandleButton').DndHandleButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+    /** Decorative insertion marker for a sortable item. */
     SortLine: ({ offset, orientation, position, ...rest }: import('./DndSortLine').SortLineProps) => import("react/jsx-runtime").JSX.Element;
+    /** Container that visualizes externally managed drop-zone state. */
     Zone: import('react').ForwardRefExoticComponent<Omit<import('./DndZone').DndZoneProps<import('react').ElementType>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
 };

package/dist/src/components/DndSort/DndSort.d.ts

@@ -1,41 +1,9 @@
 import { ReactNode } from 'react';
 import { DndSortChangeEvent } from './types';
-/**
- * Props for the DndSort component
- */
 export type DndSortProps = {
-    /**
-     * Callback function that is called when an item is dropped.
-     * Provides information about the drop event including source, destination, and validity.
-     */
+    /** Called after a drag ends, including invalid drops and drops outside a zone. */
     onDrop?: (event: DndSortChangeEvent) => void;
-    /**
-     * The content to be rendered inside the DndSort context.
-     * Should include DndSortZone and DndSortCard components.
-     */
+    /** Place `DndSort.Card` and `DndSort.Zone` descendants here. */
     children: ReactNode;
 };
-/**
- * Root component for drag and drop sorting functionality.
- *
- * Features:
- * - Provides drag and drop context for child components
- * - Supports both mouse and touch interactions
- * - Keyboard accessibility with arrow key navigation
- * - Automatic collision detection and positioning
- * - Screen reader announcements for accessibility
- * - Flexible drop event handling
- * - Supports multiple drop zones and draggable items
- * - Visual feedback during drag operations
- * - Works correctly inside animated containers (Drawer, Dialog) by disabling interactions during opening animation while keeping content visible
- *
- * @example
- * <DndSort onDrop={handleDrop}>
- *   <DndSortZone id="zone-1" label="Zone 1">
- *     <DndSortCard id="item-1" label="Item 1">
- *       Item content
- *     </DndSortCard>
- *   </DndSortZone>
- * </DndSort>
- */
 export default function DndSort({ children, onDrop, }: DndSortProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/DndSort/DndSortCard.d.ts

@@ -1,63 +1,19 @@
 import { CardProps } from '../Card';
 import { DndSortChangeEvent } from './types';
-/**
- * Props for the DndSortCard component
- * @extends Omit<CardProps, "id">
- */
 export type DndSortCardProps = Omit<CardProps, "id"> & {
-    /**
-     * The content to be displayed inside the card.
-     */
+    /** Card content, also used by the default drag preview. */
     children: React.ReactNode;
-    /**
-     * If true, the card can only be dragged when the drag handle is used.
-     * If false, the entire card can be dragged.
-     * @default false
-     */
+    /** Limits drag activation to the handle. Defaults to `false`. */
     dragOnlyWithHandle?: boolean;
-    /**
-     * The unique identifier for the card.
-     */
+    /** Stable identifier unique within the enclosing `DndSort`. */
     id: string | number;
-    /**
-     * The label for the card, used for accessibility.
-     */
+    /** Accessible name used by drag controls and live announcements. */
     label: string;
-    /**
-     * Callback function that is called when the card is dropped.
-     */
+    /** Card-level callback called alongside the root `onDrop`. */
     onDrop?: (event: DndSortChangeEvent) => void;
-    /**
-     * The type of the card, used for validation.
-     */
+    /** Value matched against a zone's `acceptedTypes`. */
     type?: string;
-    /**
-     * Function to render a custom preview of the card when it's being dragged.
-     */
+    /** Replaces the default card preview while dragging. */
     previewRenderer?: () => React.ReactNode;
 };
-/**
- * A card component that can be dragged and dropped using the DndSort system.
- *
- * Features:
- * - Draggable card with visual feedback
- * - Optional drag handle for controlled dragging
- * - Custom preview rendering during drag
- * - Type-based validation support
- * - Accessible with proper ARIA attributes
- * - Extends Card component functionality
- * - Supports both handle-only and full-card dragging
- * - Visual feedback for active drag state
- * - Flexible content rendering
- *
- * @example
- * <DndSortCard
- *   id="card-1"
- *   label="Card 1"
- *   dragOnlyWithHandle={true}
- *   onDrop={handleCardDrop}
- * >
- *   Card content here
- * </DndSortCard>
- */
 export default function DndSortCard({ children, dragOnlyWithHandle, id, label, onDrop, type, previewRenderer: previewRendererProp, ...rest }: DndSortCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/DndSort/DndSortZone.d.ts

@@ -2,129 +2,47 @@ import { ReactNode } from 'react';
 import { FlexProps } from '../Flex';
 import { GapSize } from '../../types';
 import { DndSortZoneAdvancedRenderer } from './types';
-/**
- * Common properties shared by all zone types
- */
 type CommonZoneProps = {
-    /**
-     * Array of accepted types for the drop zone. Items with matching types can be dropped here.
-     */
+    /** Allowed card types. Omit to accept every type. */
     acceptedTypes?: string[];
-    /**
-     * The content to be rendered inside the drop zone.
-     */
+    /** Default zone content when `advancedRenderer` is omitted or returns no content. */
     children?: ReactNode;
-    /**
-     * Whether the drop zone is disabled and cannot accept drops.
-     */
+    /** Forwarded to the zone root without changing drop registration. */
     disabled?: boolean;
-    /**
-     * Unique identifier for the drop zone.
-     */
+    /** Stable identifier unique within the enclosing `DndSort`. */
     id: string | number;
-    /**
-     * Label for the drop zone, used for accessibility.
-     */
+    /** Name used in live drag announcements. */
     label: string;
-    /**
-     * Function to render the drop zone using internal state parameters.
-     */
+    /** Replaces `children` with content rendered from the current drag state. */
     advancedRenderer?: DndSortZoneAdvancedRenderer;
-    /**
-     * Function to validate the drop action. Returns true for valid drops, false for invalid drops.
-     */
+    /** Additional acceptance predicate that receives the dragged card ID. */
     validator?: (id: string | number) => boolean;
 };
-/**
- * Properties for sortable zones that can reorder items
- */
 type SortableZoneProps = CommonZoneProps & {
-    /**
-     * Indicates this zone can sort and reorder items.
-     */
+    /** Enables controlled reordering within the zone. */
     sortable: true;
-    /**
-     * Array of sorted IDs for the items in the zone, must match render order.
-     */
+    /** Controlled card order. IDs must match the rendered order. */
     sortedIds: (string | number)[];
-    /**
-     * Determines where an item will be placed when dropped loosely in a zone.
-     * @default "end"
-     */
+    /** Placement when dropping on the zone itself. Defaults to `end`. */
     defaultDropPosition?: "start" | "end";
-    /**
-     * Gap size between items in the drop zone, necessary for the placement of the drop line.
-     * Must reserve space for the drop line.
-     */
+    /** Reserves space between cards for the insertion marker. Defaults to `4`. */
     gap?: Exclude<GapSize, 0 | "0" | "half">;
-    /**
-     * Orientation of the items in the drop zone.
-     */
+    /** Sorting and layout axis. */
     orientation: "horizontal" | "vertical";
 };
-/**
- * Properties for non-sortable zones that only accept drops
- */
 type NonSortableZoneProps = CommonZoneProps & {
-    /**
-     * Indicates this zone cannot sort items.
-     * @default false
-     */
+    /** Accepts drops without managing card order. Defaults to `false`. */
     sortable?: false;
-    /**
-     * Not available for non-sortable zones.
-     */
     sortedIds?: never;
-    /**
-     * Not available for non-sortable zones.
-     */
     defaultDropPosition?: never;
-    /**
-     * Gap size between items in the drop zone.
-     */
+    /** Accepts the full Flex gap scale. Defaults to `4`. */
     gap?: GapSize;
-    /**
-     * Orientation of the items in the drop zone.
-     */
+    /** Layout axis when provided. */
     orientation?: "horizontal" | "vertical";
 };
-/**
- * Props for the DndSortZone component
- */
+/** Drop-zone configuration expressed as sortable and non-sortable variants. */
 export type DndSortZoneProps = SortableZoneProps | NonSortableZoneProps;
-/**
- * Props for the DndSortZone component with Flex layout support
- * @extends Omit<FlexProps, "id" | "gap">
- * @extends DndSortZoneProps
- */
+/** `DndSort.Zone` props plus Flex layout utilities. */
 export type DndSortZonePropsWithFlexLayout = Omit<FlexProps, "id" | "gap"> & DndSortZoneProps;
-/**
- * A drop zone component for drag and drop sorting functionality.
- *
- * Features:
- * - Configurable as sortable or non-sortable zones
- * - Type-based validation for accepted items
- * - Custom validation functions
- * - Visual feedback during drag operations
- * - Flexible layout with horizontal/vertical orientation
- * - Advanced rendering with state parameters
- * - Accessible with proper ARIA attributes
- * - Extends Flex component functionality
- * - Automatic drop line positioning
- * - Support for custom gap sizing
- *
- * @example
- * <DndSortZone
- *   id="zone-1"
- *   label="Sortable Zone"
- *   sortable={true}
- *   sortedIds={["item-1", "item-2"]}
- *   orientation="vertical"
- *   acceptedTypes={["card"]}
- * >
- *   <DndSortCard id="item-1" label="Item 1">Content</DndSortCard>
- *   <DndSortCard id="item-2" label="Item 2">Content</DndSortCard>
- * </DndSortZone>
- */
 export default function DndSortZone(props: DndSortZonePropsWithFlexLayout): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/DndSort/index.d.ts

@@ -1,8 +1,14 @@
 import { default as DndSortRoot } from './DndSort';
 import { default as DndSortCard } from './DndSortCard';
 import { default as DndSortZone } from './DndSortZone';
+/**
+ * Coordinates pointer and keyboard sorting across cards and drop zones.
+ * Consumers commit the proposed placement and ordering reported through `onDrop`.
+ */
 export declare const DndSort: typeof DndSortRoot & {
+    /** Draggable card for use within `DndSort`. */
     Card: typeof DndSortCard;
+    /** Drop target that can optionally manage sortable card order. */
     Zone: typeof DndSortZone;
 };
 export { DndSortCard, DndSortZone };

package/dist/src/components/DndSort/internal/DndSortContextProvider.d.ts

@@ -1,9 +1,7 @@
 import { ReactNode } from 'react';
 import { DndSortChangeEvent } from '../types';
 /**
- * Our internal context provider for the DndSort system. Not to be confused with DndContext which is the `dnd-kit` context.
- * @param props
- * @param props.children The children components that will have access to the context
+ * Provides preview and drop state separately from dnd-kit's `DndContext`.
  */
 export default function DndSortContextProvider({ children, onDrop, }: {
     children: ReactNode;

package/dist/src/components/DndSort/internal/DndSortItem.d.ts

@@ -15,16 +15,5 @@ type DndSortItemProps = {
     onDrop?: (event: DndSortChangeEvent) => void;
     type?: string;
 };
-/**
- * A generic draggable component for the DndSort system. Can be used to create any draggable item.
- *
- * @param props
- * @param props.children A function that receives the necessary props to make the item draggable
- * @param props.id The unique identifier for the draggable item
- * @param props.label The label for the draggable item
- * @param props.onDrop The callback function to be called when the item is dropped
- * @param props.type The type of the draggable item, used for validation (optional)
- * @returns
- */
 export default function DndSortItem({ children: childrenFn, id, label, onDrop: onDropProp, type, }: DndSortItemProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/DndSort/internal/DndSortOverlay.d.ts

@@ -1,5 +1 @@
-/**
- * Component for rendering previews as items are dragged.
- * The preview is determined by the rendering function stored in context.
- */
 export default function DndSortOverlay(): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/DndSort/internal/DndSortZoneContextProvider.d.ts

@@ -1,13 +1,5 @@
 import { DndSortZoneContextValue } from './DndSortZoneContext';
 /**
- * Tells items information about the zone they are contained within.
- * @param props - The props for the DndSortZoneContextProvider component
- * @param props.children - The child components to be rendered inside the context provider
- * @param props.id - The unique identifier for the drop zone
- * @param props.sortable - Whether the drop zone is sortable
- * @param props.sortedIds - The sorted IDs of the items in the drop zone
- * @param props.orientation - The orientation of the drop zone
- 
- * @returns
+ * Makes enclosing zone configuration available to descendant sortable items.
  */
 export default function DndSortZoneContextProvider(props: DndSortZoneContextValue): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/DndSort/internal/test-utils.d.ts

@@ -17,15 +17,8 @@ type DragOptions = DragOptionsBase & ({
     to?: undefined;
 });
 /**
- *
- * @param fireEvent This can be either fireEvent from @testing-library/react or fireEvent from storybook/test
- * @param element The element to drag
- * @param options
- * @param options.to The target element or coordinates to drag to (for offset dragging see "delta")
- * @param options.delta An x/y delta to drag the element by (for target element see "to")
- * @param options.steps The number of steps in the drag action (more = smoother)
- * @param options.duration The duration of the drag action in ms
- * @param options.noDrop Don't release the item being dragged - use to test overlay
+ * Simulates a pointer drag to a target or by a delta; `noDrop` leaves the
+ * overlay open. Accepts Testing Library or Storybook `fireEvent`.
  */
 export declare function drag(fireEvent: any, element: HTMLElement, { to: inTo, delta, steps, duration, noDrop }: DragOptions): Promise<void>;
 export {};