@servicetitan/anvil2 1.44.2 → 1.45.1

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacyTrigger.d.ts

@@ -0,0 +1,21 @@
+import { TextFieldProps } from '../../../TextField/internal/TextField';
+import { LabelProps } from '../../../../internal/components/Label';
+type ComboboxLegacyTriggerProps = Omit<TextFieldProps, "disabled" | "readOnly"> & Pick<LabelProps, "required" | "moreInfo" | "openMoreInfo"> & {
+    /**
+     * Should be a positive integer.
+     */
+    maxRows?: number;
+} & {
+    /** @deprecated use disabled in <ComboboxLegacy /> */
+    disabled?: boolean;
+    /** @deprecated use readOnly in <ComboboxLegacy /> */
+    readOnly?: boolean;
+};
+export type ComboboxLegacySearchFieldProps = ComboboxLegacyTriggerProps;
+export type ComboboxLegacySelectTriggerProps = ComboboxLegacyTriggerProps;
+export declare const ComboboxLegacyTrigger: ({ className, label, size, error, hint, description, required, moreInfo, openMoreInfo, prefix, suffix, maxRows, id, disabled, readOnly, ...rest }: ComboboxLegacyTriggerProps & {
+    variant?: "combobox" | "select";
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ComboboxLegacySearchField: (props: ComboboxLegacyTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ComboboxLegacySelectTrigger: (props: ComboboxLegacyTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacyUtils.d.ts

@@ -0,0 +1,38 @@
+export declare const defaultItemToString: <Item>(item: Item | null) => string;
+export declare const defaultItemToKey: <Item>(item: Item | null) => Item | null;
+export declare const useDownshiftEnvironment: () => {
+    ref: import('react').MutableRefObject<HTMLDivElement | null>;
+    environment: {
+        document: Document;
+        addEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        Node: {
+            new (): Node;
+            prototype: Node;
+            readonly ELEMENT_NODE: 1;
+            readonly ATTRIBUTE_NODE: 2;
+            readonly TEXT_NODE: 3;
+            readonly CDATA_SECTION_NODE: 4;
+            readonly ENTITY_REFERENCE_NODE: 5;
+            readonly ENTITY_NODE: 6;
+            readonly PROCESSING_INSTRUCTION_NODE: 7;
+            readonly COMMENT_NODE: 8;
+            readonly DOCUMENT_NODE: 9;
+            readonly DOCUMENT_TYPE_NODE: 10;
+            readonly DOCUMENT_FRAGMENT_NODE: 11;
+            readonly NOTATION_NODE: 12;
+            readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+            readonly DOCUMENT_POSITION_PRECEDING: 2;
+            readonly DOCUMENT_POSITION_FOLLOWING: 4;
+            readonly DOCUMENT_POSITION_CONTAINS: 8;
+            readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+            readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+        };
+    } | undefined;
+};

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

@@ -0,0 +1,7 @@
+export { ComboboxLegacyContext, ComboboxLegacySelect, useComboboxLegacy, type ComboboxLegacyContextProps, type ComboboxLegacyProps, type ComboboxLegacySelectProps, } from './ComboboxLegacy';
+export { ComboboxLegacySearchField, ComboboxLegacySelectTrigger, type ComboboxLegacySearchFieldProps, type ComboboxLegacySelectTriggerProps, } from './ComboboxLegacyTrigger';
+export { ComboboxLegacyContent, type ComboboxLegacyContentProps, } from './ComboboxLegacyContent';
+export { ComboboxLegacyList, type ComboboxLegacyListProps, } from './ComboboxLegacyList';
+export { ComboboxLegacyItem, ComboboxLegacyItemAddNew, type ComboboxLegacyItemProps, type ComboboxLegacyItemAddNewProps, } from './ComboboxLegacyItem';
+export { ComboboxLegacyEmpty, type ComboboxLegacyEmptyProps, } from './ComboboxLegacyEmpty';
+export type { LayoutUtilProps } from '../../../../types';

package/dist/components/Combobox/internal/ComboboxMockData.d.ts

@@ -0,0 +1,44 @@
+export type TeammateItem = string;
+export declare const teammates: string[];
+export type AirportItem = {
+    id: number;
+    name: string;
+    disabled?: boolean;
+};
+export declare const airports: ({
+    id: number;
+    name: string;
+    disabled?: undefined;
+} | {
+    id: number;
+    name: string;
+    disabled: boolean;
+})[];
+export declare const tenThousandRows: {
+    id: number;
+    name: string;
+}[];
+export type DummyItem = {
+    name: string;
+    language: string;
+    id: string;
+    bio: string;
+    version: number;
+};
+export declare const dummyJSON: {
+    name: string;
+    language: string;
+    id: string;
+    bio: string;
+    version: number;
+}[];
+export declare const groupedDummyJSON: {
+    name: string;
+    items: any[];
+}[];
+export declare const dummyJSONFakeAPI: ({ page, pageSize, searchTerm, ids, }: {
+    page: number;
+    pageSize: number;
+    searchTerm?: string;
+    ids?: string[];
+}) => Promise<DummyItem[]>;

package/dist/components/Combobox/internal/ComboboxUtils.d.ts

@@ -0,0 +1,74 @@
+import { ComboboxMultipleProps, ComboboxProps, ComboboxSelectProps, SelectMultipleProps } from '../ComboboxTypes';
+export declare const ADD_NEW: unique symbol;
+/**
+ * Default function to convert an item to a string representation
+ * @template Item - The type of the item
+ * @param item - The item to convert to string
+ * @returns String representation of the item or empty string if null/undefined
+ */
+export declare const defaultItemToString: <Item>(item: Item | null) => string;
+/**
+ * Default function to generate a unique key for an item
+ * @template Item - The type of the item
+ * @param item - The item to generate a key for
+ * @returns The item itself as the key
+ */
+export declare const defaultItemToKey: <Item>(item: Item | null) => Item | null;
+/**
+ * Hook to handle downshift environment configuration for shadow DOM support
+ *
+ * Features:
+ * - Fixes shadow DOM compatibility issues with downshift
+ * - Provides proper document and event listener references
+ * - Returns ref for wrapper element and environment configuration
+ *
+ * @returns Object containing ref and environment configuration
+ *
+ * @example
+ * const { ref, environment } = useDownshiftEnvironment();
+ *
+ * return (
+ *   <div ref={ref}>
+ *     <Combobox environment={environment}>
+ *       combobox content
+ *     </Combobox>
+ *   </div>
+ * );
+ */
+export declare const useDownshiftEnvironment: () => {
+    ref: import('react').MutableRefObject<HTMLDivElement | null>;
+    environment: {
+        document: Document;
+        addEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        Node: {
+            new (): Node;
+            prototype: Node;
+            readonly ELEMENT_NODE: 1;
+            readonly ATTRIBUTE_NODE: 2;
+            readonly TEXT_NODE: 3;
+            readonly CDATA_SECTION_NODE: 4;
+            readonly ENTITY_REFERENCE_NODE: 5;
+            readonly ENTITY_NODE: 6;
+            readonly PROCESSING_INSTRUCTION_NODE: 7;
+            readonly COMMENT_NODE: 8;
+            readonly DOCUMENT_NODE: 9;
+            readonly DOCUMENT_TYPE_NODE: 10;
+            readonly DOCUMENT_FRAGMENT_NODE: 11;
+            readonly NOTATION_NODE: 12;
+            readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+            readonly DOCUMENT_POSITION_PRECEDING: 2;
+            readonly DOCUMENT_POSITION_FOLLOWING: 4;
+            readonly DOCUMENT_POSITION_CONTAINS: 8;
+            readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+            readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+        };
+    } | undefined;
+};
+export declare function isMultiple<Item>(props: ComboboxProps<Item> | ComboboxSelectProps<Item>): props is ComboboxMultipleProps<Item> | SelectMultipleProps<Item>;

package/dist/components/Combobox/internal/useGroups.d.ts

@@ -0,0 +1,14 @@
+import { ComboboxGroupByValue } from './ComboboxGroupContext';
+export declare function useGroups<Item>({ items, groupBy, groupToString, groupSorter, }: {
+    items: Item[];
+    groupBy?: string;
+    groupToString?: (key: string) => string;
+    groupSorter?: (a: ComboboxGroupByValue, b: ComboboxGroupByValue) => number;
+}): {
+    groups: {
+        items: Item[];
+        key: ComboboxGroupByValue;
+        label: string;
+    }[];
+    orderedItems: Item[];
+};

package/dist/components/Combobox/useInfiniteCombobox.d.ts

@@ -1 +1,69 @@
-export { useInfiniteCombobox, useInfiniteCombobox as default, type UseInfiniteComboboxProps, } from '@servicetitan/hammer-react';
+import { UIEvent } from 'react';
+import { UseInfiniteComboboxProps, ComboboxProps } from './ComboboxTypes';
+/**
+ * Hook for implementing infinite scroll functionality in combobox components.
+ *
+ * Features:
+ * - Automatic pagination with scroll-based loading
+ * - Configurable query triggers (input change, selection change, scroll)
+ * - Debounced query execution to prevent excessive API calls
+ * - Automatic retry logic with exponential backoff
+ * - Support for both single and multiple selection modes
+ * - Customizable scroll threshold for triggering new queries
+ * - Loading state management with deferred updates
+ * - Automatic detection of pagination end
+ * - Support for initial items or query-based initialization
+ *
+ * @param options Configuration options for the infinite combobox
+ * @returns Object containing comboboxProps and contentProps for use with Combobox component
+ *
+ * @example
+ * const { comboboxProps, contentProps } = useInfiniteCombobox({
+ *   initialItems: [],
+ *   initialPage: 0,
+ *   initialLoading: true,
+ *   query: async ({ page, inputValue, selectedItems }) => {
+ *     return await fetchItems({
+ *       page,
+ *       pageSize: 25,
+ *       searchTerm: inputValue,
+ *       excludeIds: selectedItems.map(item => item.id),
+ *     });
+ *   },
+ * });
+ *
+ * return (
+ *   <Combobox {...comboboxProps}>
+ *     <Combobox.SearchField label="Search items" />
+ *     <Combobox.Content {...contentProps}>
+ *       {({ items }) => (
+ *         <Combobox.List>
+ *           {items.map((item, i) => (
+ *             <Combobox.Item key={item.id} item={item} index={i}>
+ *               {item.name}
+ *             </Combobox.Item>
+ *           ))}
+ *         </Combobox.List>
+ *       )}
+ *     </Combobox.Content>
+ *   </Combobox>
+ * );
+ */
+export declare function useInfiniteCombobox<Item = any>({ query, queryInitialItems, initialItems, initialPage, initialLoading, initialInputValue, defaultInputValue, initialSelectedItem, defaultSelectedItem, initialSelectedItems, defaultSelectedItems, updateOnInputValueChange, updateOnSelectedItemChange, updateOnSelectedItemsChange, queryOnFirstRender, shouldTriggerQuery: shouldTriggerQueryProp, }: UseInfiniteComboboxProps<Item>): {
+    comboboxProps: {
+        items: Item[];
+        loading: boolean;
+        initialInputValue: string | undefined;
+        defaultInputValue: string | undefined;
+        initialSelectedItem: Item | null | undefined;
+        defaultSelectedItem: Item | null | undefined;
+        initialSelectedItems: Item[] | undefined;
+        defaultSelectedItems: Item[] | undefined;
+        disableFilter: boolean;
+        onStateChange: (changes: Parameters<NonNullable<ComboboxProps["onStateChange"]>>[0]) => void;
+    };
+    contentProps: {
+        onScroll: (e: UIEvent<HTMLElement>) => void;
+        scrollerRef: import('react').RefObject<HTMLDivElement>;
+    };
+};

package/dist/components/DateField/DateField.d.ts

@@ -1,73 +1,35 @@
-import { DateFieldProps as CoreDateFieldProps, DateSelect as CoreDateSelect, DateRangeSelect as CoreDateRangeSelect } from '@servicetitan/hammer-react';
+import { DataTrackingId } from '../../types';
+import { CalendarProps } from '../Calendar';
+import { TextFieldProps } from '../TextField';
+import { DateFieldCommonProps, DateFieldRangeProps, DateFieldSingleProps } from './types';
 /**
- * Props for the DateField component
- * @property {string} label - Label for the date field
- * @property {string} [placeholder] - Placeholder text for the input
- * @property {string} [description] - Helper text description
- * @property {string} [moreInfo] - Additional information text
- * @property {string} [format] - Date format (MM/dd/yyyy or dd/MM/yyyy)
- * @property {boolean} [range] - Enable date range selection mode
- * @property {Date} [minDate] - Minimum selectable date
- * @property {Date} [maxDate] - Maximum selectable date
- * @property {Date[]} [unavailableDates] - Dates that cannot be selected
- * @property {Locale} [locale] - Locale for date formatting
- * @property {IanaZone} [defaultTimeZone] - Default timezone for date operations
- * @property {boolean} [openCalendar] - Whether to open calendar on mount
- * @property {boolean} [disableHint] - Whether to disable the format hint
- * @property {string} [value] - Controlled value for the date field
- * @property {string} [defaultValue] - Default value for the date field
- * @property {(event: ChangeEvent<HTMLInputElement>, data: DateSelect | DateRangeSelect) => void} [onChange] - Callback when date selection changes
- * @extends DataTrackingId
+ * Data structure for a single date selection
  */
-export type DateFieldProps = CoreDateFieldProps & {
-    ["data-tracking-id"]?: string;
+export type DateSelect = {
+    /** The formatted date string value */
+    value: string;
+    /** The ISO date string or null if invalid */
+    date: string | null | undefined;
+    /** Whether the date is valid according to constraints */
+    isValid: boolean;
 };
 /**
- * Data structure for a single date selection
- * @property {string} value - The formatted date string value
- * @property {string | null | undefined} date - The ISO date string or null if invalid
- * @property {boolean} isValid - Whether the date is valid according to constraints
+ * Data structure for a date range selection
  */
-export type DateSelect = CoreDateSelect;
+export type DateRangeSelect = {
+    /** The start date selection */
+    start?: DateSelect;
+    /** The end date selection */
+    end?: DateSelect;
+    /** The combined formatted range string */
+    value: string;
+};
 /**
- * Data structure for a date range selection
- * @property {DateSelect} [start] - The start date selection
- * @property {DateSelect} [end] - The end date selection
- * @property {string} value - The combined formatted range string
+ * Props for the DateField component
  */
-export type DateRangeSelect = CoreDateRangeSelect;
+export type DateFieldProps = Omit<CalendarProps, "onChange" | "value" | "defaultValue"> & Omit<TextFieldProps, "prefix" | "suffix" | "hint" | "onChange" | "showCounter" | "value" | "defaultValue"> & DataTrackingId & DateFieldCommonProps & (DateFieldSingleProps | DateFieldRangeProps);
 /**
  * DateField component for selecting dates with calendar popup and input validation
  * @deprecated Use DateFieldSingle or DateFieldRange instead
- *
- * Features:
- * - Single date and date range selection modes
- * - Calendar popup with keyboard navigation
- * - Input mask validation with format hints
- * - Configurable date formats (MM/dd/yyyy, dd/MM/yyyy)
- * - Min/max date constraints and unavailable dates
- * - Locale and timezone support
- * - Accessibility with ARIA attributes
- * - Keyboard navigation and focus management
- * - Popover and legacy fallback modes
- * - Automatic tracking ID generation for analytics
- *
- * @param props - The component props
- * @param ref - Forwarded ref to the input element
- * @returns A date field component with calendar integration
- *
- * @example
- * <DateField
- *   label="Select Date"
- *   format="MM/dd/yyyy"
- *   onChange={(event, data) => console.log(data.date)}
- * />
- *
- * @example
- * <DateField
- *   label="Date Range"
- *   range={true}
- *   onChange={(event, data) => console.log(data.start?.date, data.end?.date)}
- * />
  */
 export declare const DateField: import('react').ForwardRefExoticComponent<DateFieldProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/DateField/internal/DateFieldLegacy/DateFieldLegacy.d.ts

@@ -0,0 +1,37 @@
+import { ChangeEvent } from 'react';
+import { TextFieldProps } from '../../../TextField/internal/TextField';
+import { CalendarProps } from '../../../Calendar/Calendar';
+import { IanaZone, Locale } from '../../../../types';
+interface DateFieldLegacyCommonProps {
+    format?: "MM/dd/yyyy" | "dd/MM/yyyy";
+    locale?: Locale;
+    defaultTimeZone?: IanaZone;
+    openCalendar?: boolean;
+    disableHint?: boolean;
+}
+export interface LegacyDateSelect {
+    value: string;
+    date: string | null | undefined;
+    isValid: boolean;
+}
+export interface LegacyDateRangeSelect {
+    start?: LegacyDateSelect;
+    end?: LegacyDateSelect;
+    value: string;
+}
+interface DateFieldLegacySingleProps {
+    onChange?: (event: ChangeEvent<HTMLInputElement>, data: LegacyDateSelect) => void;
+    defaultValue?: string;
+    range?: false;
+}
+interface DateFieldLegacyRangeProps {
+    onChange?: (event: ChangeEvent<HTMLInputElement>, data: LegacyDateRangeSelect) => void;
+    defaultValue?: {
+        start?: string;
+        end?: string;
+    };
+    range: true;
+}
+export type DateFieldLegacyProps = Omit<CalendarProps, "onChange"> & Omit<TextFieldProps, "prefix" | "suffix" | "hint" | "onChange" | "showCounter"> & DateFieldLegacyCommonProps & (DateFieldLegacySingleProps | DateFieldLegacyRangeProps);
+export declare const DateFieldLegacy: import('react').ForwardRefExoticComponent<DateFieldLegacyProps & import('react').RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1 @@
+export { DateFieldLegacy, type DateFieldLegacyProps, type LegacyDateSelect, type LegacyDateRangeSelect, } from './DateFieldLegacy';

package/dist/components/DateField/internal/isoToDateFormat.d.ts

@@ -0,0 +1 @@
+export declare const isoToDateFormat: (date: string, format: string) => string;

package/dist/components/DateField/types.d.ts

@@ -0,0 +1,47 @@
+import { ChangeEvent } from 'react';
+import { IanaZone, Locale } from '../../types';
+import { DateRangeSelect, DateSelect } from './DateField';
+export interface DateFieldCommonProps {
+    /** Date format for input and display */
+    format?: "MM/dd/yyyy" | "dd/MM/yyyy";
+    /** Locale for date formatting */
+    locale?: Locale;
+    /** Default timezone for date operations */
+    defaultTimeZone?: IanaZone;
+    /** Whether to open calendar on mount */
+    openCalendar?: boolean;
+    /** Whether to disable the format hint */
+    disableHint?: boolean;
+}
+/**
+ * Props for single date selection mode
+ */
+export interface DateFieldSingleProps {
+    /** Callback when date selection changes */
+    onChange?: (event: ChangeEvent<HTMLInputElement>, data: DateSelect) => void;
+    /** Controlled value for the date field */
+    value?: string;
+    /** Default value for the date field */
+    defaultValue?: string;
+    /** Must be false for single date mode */
+    range?: false;
+}
+/**
+ * Props for date range selection mode
+ */
+export interface DateFieldRangeProps {
+    /** Callback when date range selection changes */
+    onChange?: (event: ChangeEvent<HTMLInputElement>, data: DateRangeSelect) => void;
+    /** Controlled value for the date range field */
+    value?: {
+        start?: string;
+        end?: string;
+    };
+    /** Default value for the date range field */
+    defaultValue?: {
+        start?: string;
+        end?: string;
+    };
+    /** Must be true for range mode */
+    range: true;
+}

package/dist/components/DateFieldRange/DateFieldRange.d.ts

@@ -1,9 +1,60 @@
-import { DateFieldRangeProps as CoreDateFieldRangeProps, DateFieldRangeChange as CoreDateFieldRangeChange, DateFieldRangeChangeHandler as CoreDateFieldRangeChangeHandler, DateMode as CoreDateMode } from '@servicetitan/hammer-react';
-import { DataTrackingId } from '../../types/DataTrackingId';
-export type DateFieldRangeProps = CoreDateFieldRangeProps & DataTrackingId;
-export type DateFieldRangeChange = CoreDateFieldRangeChange;
-export type DateFieldRangeChangeHandler = CoreDateFieldRangeChangeHandler;
-export type DateMode = CoreDateMode;
+import { DataTrackingId } from '../../types';
+import { MaskedDateRangeInputProps } from './internal/MaskedDateRangeInput';
+import { DateMode } from '../DateFieldSingle/types';
+export type DateFieldRangeChange = {
+    /**
+     * The start date in ISO 8601 format.
+     * @example "2025-03-22"
+     */
+    startDate: string | null;
+    /**
+     * The end date in ISO 8601 format.
+     * @example "2025-07-02"
+     */
+    endDate: string | null;
+    /**
+     * Whether the input field contains two parsable dates.
+     * This is not the same as the date range being valid.
+     *
+     */
+    isInputValid: boolean;
+    /**
+     * Whether the input field is empty.
+     */
+    isInputEmpty: boolean;
+    /**
+     * Whether the start and end dates are valid according to the constraints.
+     * Constraints include:
+     * - Required
+     * - Unavailable dates
+     * - Unavailable days of the week
+     * - Min date
+     * - Max date
+     */
+    isDateRangeValid: boolean;
+};
+export type DateFieldRangeChangeHandler = (change: DateFieldRangeChange) => void;
+export type DateFieldRangeValue = {
+    startDate: string | null;
+    endDate: string | null;
+} | null;
+export type DateFieldRangeProps = Omit<MaskedDateRangeInputProps, "onChange" | "value" | "autoComplete" | "onClick" | "onKeyDown" | "ref" | "required" | "startDate" | "endDate" | "defaultValue" | "onFocus" | "onBlur"> & {
+    value?: DateFieldRangeValue;
+    defaultValue?: DateFieldRangeValue;
+    onChange?: DateFieldRangeChangeHandler;
+    mode?: Extract<DateMode, "mm/dd/yyyy" | "dd/mm/yyyy">;
+    disableHint?: boolean;
+    disableCalendar?: boolean;
+    unavailable?: {
+        dates?: string[];
+        daysOfWeek?: (1 | 2 | 3 | 4 | 5 | 6 | 7)[];
+    };
+    minDate?: string;
+    maxDate?: string;
+    required?: boolean;
+    onFocus?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+} & DataTrackingId;
 export declare const DateFieldRange: {
     (props: DateFieldRangeProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

package/dist/components/DateFieldRange/internal/DateFieldRangeCalendar.d.ts

@@ -0,0 +1,17 @@
+import { DateTime, WeekdayNumbers } from 'luxon';
+export type DateFieldRangeCalendarProps = {
+    startDate: DateTime | null;
+    endDate: DateTime | null;
+    onKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    onSelection: ({ startDate, endDate, }: {
+        startDate: DateTime | null;
+        endDate: DateTime | null;
+    }) => void;
+    minDate?: DateTime | null;
+    maxDate?: DateTime | null;
+    unavailable?: {
+        dates?: DateTime[];
+        daysOfWeek?: WeekdayNumbers[];
+    };
+};
+export declare const DateFieldRangeCalendar: ({ startDate, endDate, onKeyDown, onSelection, minDate, maxDate, unavailable, }: DateFieldRangeCalendarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/DateFieldRange/internal/MaskedDateRangeInput.d.ts

@@ -0,0 +1,41 @@
+import { TextFieldProps } from '../../TextField/internal/TextField';
+import { DateTime } from 'luxon';
+import { DateMode } from '../../DateFieldSingle/types';
+export type MaskedDateRangeInputChange = {
+    startDate: DateTime | null;
+    endDate: DateTime | null;
+    isInputValid: boolean;
+    isInputEmpty: boolean;
+};
+export type MaskedDateRangeInputChangeHandler = (change: MaskedDateRangeInputChange) => void;
+export type MaskedDateRangeInputProps = Omit<TextFieldProps, "onChange" | "value" | "ref" | "showCounter" | "hint" | "prefix"> & {
+    onChange: MaskedDateRangeInputChangeHandler;
+    mode?: DateMode;
+    startDate: DateTime | null;
+    endDate: DateTime | null;
+    disableHint?: boolean;
+};
+export type MaskedDateRangeInputRef = HTMLInputElement & {
+    setDateRange: (startDate: DateTime | null, endDate: DateTime | null) => void;
+};
+/**
+ * A masked date input component that allows for the input of a date in a specific format.
+ *
+ * Provides a `setDates` method that can be used to set the date from outside the component (e.g from a calendar).
+ *
+ * @internal This component is not intended to be used directly in consumer code.
+ *
+ * @param props - The props for the MaskedDateRangeInput component.
+ * @param props.onChange - The function to call when the date changes.
+ * @param props.mode - The mode of the date input.
+ * @param props.startDate - The start date.
+ * @param props.endDate - The end date.
+ * @param props.disableHint - Whether to disable the hint.
+ */
+export declare const MaskedDateRangeInput: import('react').ForwardRefExoticComponent<Omit<TextFieldProps, "ref" | "value" | "onChange" | "prefix" | "hint" | "showCounter"> & {
+    onChange: MaskedDateRangeInputChangeHandler;
+    mode?: DateMode;
+    startDate: DateTime | null;
+    endDate: DateTime | null;
+    disableHint?: boolean;
+} & import('react').RefAttributes<MaskedDateRangeInputRef>>;

package/dist/components/DateFieldRange/internal/maskito/dateRangePlaceholderMask.d.ts

@@ -0,0 +1,18 @@
+import { MaskitoDateMode } from '@maskito/kit';
+export type DateMode = Extract<MaskitoDateMode, "dd/mm/yyyy" | "mm/dd/yyyy" | "yyyy/mm/dd">;
+declare const datePlaceholderMask: ({ mode, dateSeparator, rangeSeparator, placeholder, }: {
+    mode: DateMode;
+    dateSeparator?: string;
+    rangeSeparator?: string;
+    placeholder: string;
+}) => {
+    options: {
+        plugins: import('@maskito/core').MaskitoPlugin[];
+        preprocessors: import('@maskito/core').MaskitoPreprocessor[];
+        postprocessors: import('@maskito/core').MaskitoPostprocessor[];
+        mask: import('@maskito/core').MaskitoMask;
+        overwriteMode: "replace" | "shift" | ((elementState: import('@maskito/core/src/lib/types').ElementState) => "replace" | "shift");
+    };
+    removePlaceholder: (value: string) => string;
+};
+export default datePlaceholderMask;

package/dist/components/DateFieldRange/internal/useDateFieldRangeConversion.d.ts

@@ -0,0 +1,29 @@
+import { DateFieldRangeChange, DateFieldRangeProps } from '../DateFieldRange';
+import { DateTime } from 'luxon';
+/**
+ * This hook is used to convert the string props of a DateFieldRange component to a DateTime format.
+ *
+ * @param props - The props of the DateFieldRange component.
+ * @returns The normalized value, defaultValue, minDate, maxDate, and unavailable dates in DateTime format.
+ * @internal This hook is not intended to be used directly in consumer code.
+ */
+export declare const useDateFieldRangeConversion: (props: DateFieldRangeProps) => {
+    value: {
+        startDate: DateTime<boolean> | null;
+        endDate: DateTime<boolean> | null;
+    } | null | undefined;
+    defaultValue: {
+        startDate: DateTime<boolean> | null;
+        endDate: DateTime<boolean> | null;
+    } | null | undefined;
+    minDate: DateTime<boolean> | null | undefined;
+    maxDate: DateTime<boolean> | null | undefined;
+    unavailable: {
+        dates: DateTime<boolean>[] | undefined;
+        daysOfWeek: (3 | 1 | 2 | 4 | 5 | 6 | 7)[] | undefined;
+    };
+    onChange: (change: Omit<DateFieldRangeChange, "startDate" | "endDate"> & {
+        startDate: DateTime | null;
+        endDate: DateTime | null;
+    }) => void;
+};