@servicetitan/anvil2 1.44.2 → 1.45.1

package/dist/info-CYpG6tcI.js

@@ -0,0 +1,6 @@
+import * as React from 'react';
+
+const SvgInfo = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: "1em", height: "1em", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("path", { d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 15c-.55 0-1-.45-1-1v-4c0-.55.45-1 1-1s1 .45 1 1v4c0 .55-.45 1-1 1zm1-8h-2V7h2v2z" }));
+
+export { SvgInfo as S };
+//# sourceMappingURL=info-CYpG6tcI.js.map

package/dist/info-CYpG6tcI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"info-CYpG6tcI.js","sources":["../../hammer-icon/mdi/round/info.svg"],"sourcesContent":["import * as React from \"react\";\nconst SvgInfo = (props) => /* @__PURE__ */ React.createElement(\"svg\", { xmlns: \"http://www.w3.org/2000/svg\", width: \"1em\", height: \"1em\", viewBox: \"0 0 24 24\", ...props }, /* @__PURE__ */ React.createElement(\"path\", { d: \"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 15c-.55 0-1-.45-1-1v-4c0-.55.45-1 1-1s1 .45 1 1v4c0 .55-.45 1-1 1zm1-8h-2V7h2v2z\" }));\nexport default SvgInfo;\n"],"names":[],"mappings":";;AACK,MAAC,OAAO,GAAG,CAAC,KAAK,qBAAqB,KAAK,CAAC,aAAa,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,4BAA4B,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,KAAK,EAAE,kBAAkB,KAAK,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,uJAAuJ,EAAE,CAAC;;;;"}

package/dist/internal/components/Helper/Helper.d.ts

@@ -0,0 +1,18 @@
+import { AriaAttributes, ReactElement } from 'react';
+export type HelperProps = {
+    id?: string;
+    hint?: ReactElement | string;
+    description?: ReactElement | string;
+    errorMessage?: ReactElement | string;
+    /**
+     * aria-live for the error message
+     * @default assertive
+     * @link https://www.w3.org/WAI/tutorials/forms/notifications/
+     */
+    errorAriaLive?: AriaAttributes["aria-live"];
+    maxLength?: number;
+    inputLength?: number;
+    isTyping?: boolean;
+    showCounter?: boolean;
+};
+export declare const Helper: import('react').ForwardRefExoticComponent<HelperProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/internal/components/Helper/index.d.ts

@@ -0,0 +1 @@
+export { type HelperProps, Helper } from './Helper';

package/dist/internal/components/Label/Label.d.ts

@@ -0,0 +1,77 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+import { TooltipProps } from '../../../components';
+/**
+ * Props for the Label component.
+ */
+export type LabelProps = Omit<ComponentPropsWithoutRef<"label">, "id"> & {
+    /** Unique identifier for the label element */
+    id?: string;
+    /**
+     * Whether the field is required. Shows a red asterisk (*) when true.
+     * @default false
+     */
+    required?: boolean;
+    /** Additional information to display in a tooltip */
+    moreInfo?: ReactNode;
+    /**
+     * Controls the open state of the more info tooltip.
+     * @default false
+     */
+    openMoreInfo?: TooltipProps["open"];
+};
+/**
+ * Internal component for rendering the info icon with tooltip.
+ *
+ * @param props - Component props
+ * @param props.moreInfo - The content to display in the tooltip
+ * @param props.openMoreInfo - Controls the tooltip open state
+ */
+export declare const LabelMoreInfoIcon: ({ moreInfo, openMoreInfo, }: {
+    moreInfo: LabelProps["moreInfo"];
+    openMoreInfo: LabelProps["openMoreInfo"];
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Label component for form field labels with optional required indicator and help tooltip.
+ *
+ * Features:
+ * - Accessible form label with proper semantic HTML
+ * - Optional required field indicator with red asterisk
+ * - Help tooltip with info icon for additional context
+ * - Screen reader support for required field announcement
+ * - Controlled and uncontrolled tooltip state management
+ * - Flexible content support for label text and help information
+ * - Proper ARIA attributes and semantic structure
+ * - Responsive design with consistent typography
+ *
+ * @example
+ * <Label htmlFor="email" required>
+ *   Email Address
+ * </Label>
+ * <input id="email" type="email" />
+ *
+ * @example
+ * <Label
+ *   htmlFor="password"
+ *   required
+ *   moreInfo="Password must be at least 8 characters long"
+ * >
+ *   Password
+ * </Label>
+ * <input id="password" type="password" />
+ */
+export declare const Label: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref">, "id"> & {
+    /** Unique identifier for the label element */
+    id?: string;
+    /**
+     * Whether the field is required. Shows a red asterisk (*) when true.
+     * @default false
+     */
+    required?: boolean;
+    /** Additional information to display in a tooltip */
+    moreInfo?: ReactNode;
+    /**
+     * Controls the open state of the more info tooltip.
+     * @default false
+     */
+    openMoreInfo?: TooltipProps["open"];
+} & import('react').RefAttributes<HTMLLabelElement>>;

package/dist/internal/components/Label/index.d.ts

@@ -0,0 +1,2 @@
+export { Label, type LabelProps } from './Label';
+export type { LayoutUtilProps } from '../../../types';

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

@@ -1 +1,3 @@
+export * from './Helper';
 export * from './Shadow';
+export * from './Label';

package/dist/internal/functions/childrenToString.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+/**
+ * Recursively extracts text content from React children nodes.
+ *
+ * Features:
+ * - Converts React children to plain text string
+ * - Handles all React node types (strings, numbers, booleans, arrays, elements)
+ * - Recursively processes nested React elements
+ * - Extracts text from element children props
+ * - Handles empty and null children gracefully
+ * - Joins array children into single string
+ * - Filters out non-text content automatically
+ * - Returns empty string for unsupported node types
+ *
+ * Supported Node Types:
+ * - String, number, boolean (converted to string)
+ * - React elements (extracts children recursively)
+ * - Arrays (processes each item and joins)
+ * - Null, undefined (returns empty string)
+ * - Objects (returns empty string)
+ *
+ * @param node - React node to convert to string
+ * @returns Extracted text content as string, or empty string if no text content
+ */
+export declare function childrenToString(node: ReactNode | object): string;

package/dist/internal/functions/getActiveElement.d.ts

@@ -0,0 +1 @@
+export declare const getActiveElement: (activeDocument: Document | ShadowRoot) => HTMLElement | null;

package/dist/internal/functions/getInitial.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Extracts initials from a full name string.
+ *
+ * Features:
+ * - Handles single names (returns first two characters)
+ * - Handles multiple names (returns first and last name initials)
+ * - Automatically capitalizes all initials
+ * - Filters out empty strings and whitespace
+ * - Handles edge cases like empty names and single characters
+ * - Preserves proper capitalization rules
+ * - Returns undefined for empty or falsy input
+ *
+ * @param name - The full name string to extract initials from
+ * @returns The initials as a string, or undefined if name is empty
+ */
+export declare function getInitial(name: string): string | undefined;

package/dist/internal/functions/getKeyboardFocusableElements.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Retrieves all keyboard focusable elements within a given container element.
+ *
+ * Features:
+ * - Finds all elements that can receive keyboard focus
+ * - Filters out disabled, hidden, and inert elements
+ * - Respects ARIA attributes for accessibility
+ * - Checks computed styles for visibility
+ * - Supports all standard focusable elements (links, buttons, inputs, etc.)
+ * - Handles null and undefined input gracefully
+ * - Returns array of focusable HTMLElements
+ * - Excludes elements with tabindex="-1"
+ *
+ * Focusable Elements Detected:
+ * - Links with href attributes
+ * - Buttons (all types)
+ * - Form inputs (text, checkbox, radio, etc.)
+ * - Textareas and select elements
+ * - Details elements
+ * - Elements with positive tabindex values
+ *
+ * @param element - The container element to search for focusable elements
+ * @returns Array of focusable HTMLElements, or empty array if no element provided
+ */
+export declare function getKeyboardFocusableElements(element?: HTMLElement | null): Element[];

package/dist/internal/functions/index.d.ts

@@ -0,0 +1,9 @@
+export * from './childrenToString';
+export * from './getActiveElement';
+export * from './getInitial';
+export * from './getKeyboardFocusableElements';
+export * from './kebabize';
+export * from './mapOrder';
+export * from './safePopover';
+export * from './sizeToToken';
+export * from './supportsPopover';

package/dist/internal/functions/kebabize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts a camelCase or PascalCase string to kebab-case format.
+ *
+ * Features:
+ * - Handles camelCase to kebab-case conversion
+ * - Handles PascalCase to kebab-case conversion
+ * - Preserves consecutive numbers without separators
+ * - Adds hyphens before uppercase letters and numbers
+ * - Maintains lowercase letters as-is
+ * - Handles edge cases like single characters and empty strings
+ * - Preserves existing hyphens in the input string
+ *
+ * @param str - The string to convert to kebab-case
+ * @returns The kebab-case version of the input string
+ */
+export declare function kebabize(str: string): string;

package/dist/internal/functions/mapOrder.d.ts

@@ -0,0 +1 @@
+export declare function mapOrder(array: any[], order: any[], key: string): any[];

package/dist/internal/functions/safePopover.d.ts

@@ -0,0 +1,2 @@
+export declare const safeShowPopover: (element?: HTMLElement) => void;
+export declare const safeHidePopover: (element?: HTMLElement) => void;

package/dist/internal/functions/sizeToToken.d.ts

@@ -0,0 +1,2 @@
+import { GapSize } from '../../types';
+export declare const sizeToToken: (value?: GapSize) => string | undefined;

package/dist/internal/functions/supportsPopover.d.ts

@@ -0,0 +1 @@
+export declare function supportsPopover(): boolean;

package/dist/internal/hooks/index.d.ts

@@ -0,0 +1,17 @@
+export * from './useDialogScrollLock';
+export * from './useDialogTransitionStates';
+export * from './useFocusWithin';
+export * from './useIntersectionObserver';
+export * from './useIsScrollable';
+export * from './useKeyboardFocusables';
+export * from './useLayoutPropsUtil';
+export * from './useNumberField';
+export * from './useOnClickOutside';
+export * from './useOpenCloseTransitionStates';
+export * from './useOptionallyControlledState/useOptionallyControlledState';
+export * from './usePlatform/usePlatform';
+export * from './usePopoverCloseDelayWorkaround';
+export * from './usePopoverSupport';
+export * from './usePopoverTransitionStates';
+export * from './usePrevious';
+export * from './useTypeAhead';

package/dist/internal/hooks/useDialogScrollLock/index.d.ts

@@ -0,0 +1 @@
+export { useDialogScrollLock, type UseDialogScrollLockProps, } from './useDialogScrollLock';

package/dist/internal/hooks/useDialogScrollLock/useDialogScrollLock.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Props for the useDialogScrollLock hook
+ * @property {boolean} open - Whether the dialog is open
+ * @property {string} id - Unique identifier for the dialog
+ * @property {boolean} [enableScrollChaining] - Whether to enable scroll chaining
+ * @property {React.RefObject<HTMLElement>} elementRef - Reference to the dialog element
+ */
+export interface UseDialogScrollLockProps {
+    /**
+     * Whether the dialog is open
+     */
+    open: boolean;
+    /**
+     * Unique identifier for the dialog
+     */
+    id: string;
+    /**
+     * Whether to enable scroll chaining
+     */
+    enableScrollChaining?: boolean;
+    /**
+     * Reference to the dialog element
+     */
+    elementRef: React.RefObject<HTMLElement>;
+}
+/**
+ * Custom hook for managing dialog scroll lock in shadow DOM environments.
+ *
+ * Features:
+ * - Manages scroll lock state for dialogs in shadow DOM
+ * - Tracks multiple open dialogs with unique IDs
+ * - Prevents scroll chaining when dialogs are open
+ * - Automatically cleans up scroll lock on unmount
+ * - Supports enabling/disabling scroll chaining
+ * - Uses data attributes to track dialog state
+ *
+ * @param props - Configuration object containing dialog state and element reference
+ * @returns void
+ */
+export declare const useDialogScrollLock: ({ open, id, enableScrollChaining, elementRef, }: UseDialogScrollLockProps) => void;

package/dist/internal/hooks/useDialogTransitionStates/index.d.ts

@@ -0,0 +1 @@
+export { useDialogTransitionStates } from './useDialogTransitionStates';

package/dist/internal/hooks/useDialogTransitionStates/useDialogTransitionStates.d.ts

@@ -0,0 +1,32 @@
+import { RefObject } from 'react';
+import { OpenCloseTransitionStateEffects } from '../useOpenCloseTransitionStates';
+/**
+ * Effects configuration for dialog transition states
+ * @property {() => void} [onOpenAnimationStart] - Callback when opening animation starts
+ * @property {() => void} [onCloseAnimationStart] - Callback when closing animation starts
+ * @property {() => void} [onOpenAnimationComplete] - Callback when opening animation completes
+ * @property {() => void} [onCloseAnimationComplete] - Callback when closing animation completes
+ */
+/**
+ * Custom hook for managing dialog transition states and animations.
+ *
+ * Features:
+ * - Manages dialog open/close transition states
+ * - Handles animation timing based on CSS animation duration
+ * - Provides callbacks for animation lifecycle events
+ * - Supports controlled dialog state management
+ * - Automatically handles showModal() and close() calls
+ * - Provides utility flags for open/closed states
+ *
+ * @param ref - The ref to the dialog element
+ * @param openProp - The open prop controlling dialog visibility
+ * @param options - Additional, optional options including callbacks for animation start, complete, and initialization
+ * @returns Object containing dialog state, control functions, and utility flags
+ */
+/**
+ * Effects configuration for dialog transition states
+ * @param openProp - The open prop controlling dialog visibility
+ * @param options - The effects configuration
+ * @returns The dialog transition state
+ */
+export declare const useDialogTransitionStates: (ref: RefObject<HTMLDialogElement>, openProp: boolean | undefined, options?: OpenCloseTransitionStateEffects) => import('..').OpenCloseTransitionState;

package/dist/internal/hooks/useFocusWithin/index.d.ts

@@ -0,0 +1 @@
+export * from './useFocusWithin';

package/dist/internal/hooks/useFocusWithin/useFocusWithin.d.ts

@@ -0,0 +1,33 @@
+export interface UseFocusWithinOptions {
+    onFocus?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+}
+export interface UseFocusWithinReturnValue<T extends HTMLElement = any> {
+    ref: React.RefObject<T>;
+    focused: boolean;
+}
+/**
+ * Custom hook for tracking focus state within a DOM element.
+ *
+ * Features:
+ * - Tracks whether any child element has focus
+ * - Provides a ref object to attach to the target element
+ * - Handles focus events with proper cleanup
+ * - Supports custom onFocus and onBlur callbacks
+ * - Prevents false blur events when focus moves between children
+ * - Automatically cleans up event listeners on unmount
+ *
+ * @param options Configuration options for the hook
+ * @param options.onFocus Optional callback when focus enters the element
+ * @param options.onBlur Optional callback when focus leaves the element
+ * @returns Object containing ref and focused state
+ *
+ * @example
+ * const { ref, focused } = useFocusWithin({
+ *   onFocus: () => console.log('Focus entered'),
+ *   onBlur: () => console.log('Focus left')
+ * });
+ *
+ * return <div ref={ref} className={focused ? 'focused' : ''}>Content</div>;
+ */
+export declare function useFocusWithin<T extends HTMLElement = any>({ onBlur, onFocus, }?: UseFocusWithinOptions): UseFocusWithinReturnValue<T>;

package/dist/internal/hooks/useIntersectionObserver/index.d.ts

@@ -0,0 +1 @@
+export { useIntersectionObserver, type UseIntersectionObserverOptions, type IntersectionReturn, } from './useIntersectionObserver';

package/dist/internal/hooks/useIntersectionObserver/useIntersectionObserver.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Options for the useIntersectionObserver hook
+ * @property {Element | Document | null} [root] - The root element for intersection calculations
+ * @property {string} [rootMargin] - Margin around the root element
+ * @property {number | number[]} [threshold] - Threshold values for intersection detection
+ * @property {boolean} [freezeOnceVisible] - Whether to freeze once the element becomes visible
+ * @property {(isIntersecting: boolean, entry: IntersectionObserverEntry) => void} [onChange] - Callback when intersection changes
+ * @property {boolean} [initialIsIntersecting] - Initial intersection state
+ */
+export type UseIntersectionObserverOptions = {
+    /**
+     * The root element for intersection calculations
+     */
+    root?: Element | Document | null;
+    /**
+     * Margin around the root element
+     */
+    rootMargin?: string;
+    /**
+     * Threshold values for intersection detection
+     */
+    threshold?: number | number[];
+    /**
+     * Whether to freeze once the element becomes visible
+     */
+    freezeOnceVisible?: boolean;
+    /**
+     * Callback when intersection changes
+     */
+    onChange?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
+    /**
+     * Initial intersection state
+     */
+    initialIsIntersecting?: boolean;
+};
+/**
+ * Return type for the useIntersectionObserver hook
+ * @property {(node?: Element | null) => void} ref - Function to set the element to observe
+ * @property {boolean} isIntersecting - Whether the element is intersecting
+ * @property {IntersectionObserverEntry} [entry] - The intersection observer entry
+ */
+export type IntersectionReturn = [
+    (node?: Element | null) => void,
+    boolean,
+    IntersectionObserverEntry | undefined
+] & {
+    ref: (node?: Element | null) => void;
+    isIntersecting: boolean;
+    entry?: IntersectionObserverEntry;
+};
+/**
+ * Custom hook for observing element intersection with viewport or root element.
+ *
+ * Features:
+ * - Observes element intersection with viewport or custom root element
+ * - Supports configurable threshold values and root margins
+ * - Provides intersection state and detailed entry information
+ * - Supports freezing observation once element becomes visible
+ * - Handles browser compatibility gracefully
+ * - Provides both array and object destructuring support
+ * - Automatically cleans up observer on unmount
+ * - Supports onChange callback for custom intersection handling
+ *
+ * @param options - Configuration options for the intersection observer
+ * @returns Array containing ref function, intersection state, and entry, with additional object properties
+ */
+export declare function useIntersectionObserver({ threshold, root, rootMargin, freezeOnceVisible, initialIsIntersecting, onChange, }?: UseIntersectionObserverOptions): IntersectionReturn;

package/dist/internal/hooks/useIsScrollable/index.d.ts

@@ -0,0 +1 @@
+export { useIsScrollable } from './useIsScrollable';

package/dist/internal/hooks/useIsScrollable/useIsScrollable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Custom hook to detect if an element is horizontally scrollable
+ * @param element The HTML element to check for horizontal scrollability
+ * @returns boolean indicating if the element is horizontally scrollable
+ */
+export declare const useIsScrollable: (element: HTMLElement | null) => boolean;

package/dist/internal/hooks/useKeyboardFocusables/index.d.ts

@@ -0,0 +1 @@
+export { useKeyboardFocusables } from './useKeyboardFocusables';

package/dist/internal/hooks/useKeyboardFocusables/useKeyboardFocusables.d.ts

@@ -0,0 +1,54 @@
+import { RefObject } from 'react';
+import { FocusableElement } from 'tabbable';
+/**
+ * Options for the useKeyboardFocusables hook
+ */
+type OptionProps = {
+    /**
+     * Disable mutation observer
+     */
+    observeChange: false;
+} | {
+    /**
+     * Enable mutation observer with optional configuration
+     */
+    observeChange: true;
+    /**
+     * Observe attribute changes
+     */
+    attributes?: boolean;
+    /**
+     * Observe text content changes
+     */
+    characterData?: boolean;
+    /**
+     * Observe child element changes
+     */
+    childList?: boolean;
+    /**
+     * Observe descendant changes
+     */
+    subtree?: boolean;
+};
+/**
+ * Custom hook for tracking keyboard focusable elements within a container.
+ *
+ * Features:
+ * - Tracks all keyboard focusable elements within a target container
+ * - Supports both ref objects and direct element references
+ * - Optional mutation observer for real-time updates
+ * - Debounced updates to prevent excessive re-renders
+ * - Configurable mutation observer options
+ * - Manual update function for immediate refresh
+ * - Uses tabbable library for accurate focusable detection
+ * - Automatically cleans up mutation observer
+ *
+ * @param element - Target element or ref to monitor for focusable elements
+ * @param options - Configuration options for mutation observer behavior
+ * @returns Object containing current focusable elements and update function
+ */
+export declare const useKeyboardFocusables: (element: RefObject<HTMLElement> | HTMLElement | undefined, options?: OptionProps) => {
+    focusables: FocusableElement[] | null;
+    updateFocusables: () => void;
+};
+export {};

package/dist/internal/hooks/useLayoutPropsUtil/index.d.ts

@@ -0,0 +1 @@
+export { useLayoutPropsUtil } from './useLayoutPropsUtil';

package/dist/internal/hooks/useLayoutPropsUtil/useLayoutPropsUtil.d.ts

@@ -0,0 +1,56 @@
+import { CSSProperties } from 'react';
+import { LayoutUtilProps } from '../../../types';
+/**
+ * Responsive layout configuration type
+ */
+type ResponsiveLayout = {
+    /**
+     * Base layout properties
+     */
+    base?: LayoutUtilProps;
+    /**
+     * Extra small breakpoint layout properties
+     */
+    xs?: LayoutUtilProps;
+    /**
+     * Small breakpoint layout properties
+     */
+    sm?: LayoutUtilProps;
+    /**
+     * Medium breakpoint layout properties
+     */
+    md?: LayoutUtilProps;
+    /**
+     * Large breakpoint layout properties
+     */
+    lg?: LayoutUtilProps;
+    /**
+     * Extra large breakpoint layout properties
+     */
+    xl?: LayoutUtilProps;
+    /**
+     * Extra extra large breakpoint layout properties
+     */
+    xxl?: LayoutUtilProps;
+};
+/**
+ * Custom hook for managing responsive layout properties and CSS styles.
+ *
+ * Features:
+ * - Separates layout properties from component properties
+ * - Provides responsive breakpoint support for all layout properties
+ * - Automatically converts gap sizes to CSS tokens
+ * - Uses breakpoint cascade for responsive values
+ * - Optimized with useMemo for performance
+ * - Supports all CSS Grid and Flexbox properties
+ * - Handles responsive size inheritance (larger breakpoints inherit from smaller ones)
+ * - Returns both layout styles and filtered component props
+ *
+ * @param props - Object containing layout and component properties
+ * @returns Object containing layout styles and filtered component props
+ */
+export declare function useLayoutPropsUtil<T extends ResponsiveLayout>(props: T): {
+    layoutStyles?: CSSProperties;
+    componentProps: T;
+};
+export {};

package/dist/internal/hooks/useNumberField/index.d.ts

@@ -0,0 +1 @@
+export { useNumberField } from './useNumberField';

package/dist/internal/hooks/useNumberField/internal/useNumberFieldInputMode.d.ts

@@ -0,0 +1,24 @@
+export type InputMode = "decimal" | "numeric" | "text";
+/**
+ * Custom hook that determines the optimal inputMode attribute for number fields based on platform and requirements.
+ *
+ * The inputMode attribute tells the device what type of software keyboard to show.
+ * There are inconsistencies in what each software keyboard includes across different platforms:
+ * - iPhone lacks a minus sign in both numeric and decimal keyboards
+ * - Android numeric keyboard has both decimal point and minus sign
+ * - iPad has different keyboard behavior than iPhone
+ *
+ * @param hasDecimals - Whether the number field allows decimal values
+ * @param hasNegative - Whether the number field allows negative values
+ * @returns The optimal inputMode attribute to use on the number field
+ *
+ * @example
+ * const inputMode = useNumberFieldInputMode({
+ *   hasDecimals: true,
+ *   hasNegative: false
+ * });
+ */
+export declare const useNumberFieldInputMode: ({ hasDecimals, hasNegative, }: {
+    hasDecimals: boolean;
+    hasNegative: boolean;
+}) => InputMode;

package/dist/internal/hooks/useNumberField/internal/useNumberFieldKeys.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Configuration for the useNumberFieldKeys hook
+ */
+export type UseNumberFieldKeysConfig = {
+    /** Function to increment the value by a specified amount */
+    increment: (amount: number) => void;
+    /** Function to decrement the value by a specified amount */
+    decrement: (amount: number) => void;
+    /** Function to set the value to the minimum allowed value */
+    setToMin: () => void;
+    /** Function to set the value to the maximum allowed value */
+    setToMax: () => void;
+    /** The step value for increment/decrement operations */
+    step: number;
+    /** Multiplier for large step operations (PageUp/PageDown) */
+    largeStepMultiplier: number;
+};
+/**
+ * Custom hook that handles keyboard interactions for number fields.
+ *
+ * This hook provides keyboard navigation support for number input fields:
+ * - Arrow Up/Down: Increment/decrement by step value
+ * - Page Up/Down: Increment/decrement by step * largeStepMultiplier
+ * - Home: Set to minimum value
+ * - End: Set to maximum value
+ *
+ * @param config - Configuration object containing increment/decrement functions and step values
+ * @returns Object containing the input ref to attach to the input element
+ *
+ * @example
+ * const { inputRef } = useNumberFieldKeys({
+ *   increment: (amount) => setValue(prev => prev + amount),
+ *   decrement: (amount) => setValue(prev => prev - amount),
+ *   setToMin: () => setValue(minValue),
+ *   setToMax: () => setValue(maxValue),
+ *   step: 1,
+ *   largeStepMultiplier: 10
+ * });
+ */
+declare function useNumberFieldKeys(config: UseNumberFieldKeysConfig): {
+    inputRef: import('react').RefObject<HTMLInputElement>;
+};
+export default useNumberFieldKeys;