@salt-ds/lab 1.0.0-alpha.55 → 1.0.0-alpha.56

package/dist-types/calendar/Calendar.d.ts

@@ -1,5 +1,6 @@
 import { type ComponentPropsWithoutRef, type ReactNode } from "react";
 import { type UseCalendarMultiSelectProps, type UseCalendarOffsetProps, type UseCalendarRangeProps, type UseCalendarSingleProps } from "./useCalendar";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 /**
  * Base props for the Calendar component.
  */
@@ -12,11 +13,15 @@ export interface CalendarBaseProps extends ComponentPropsWithoutRef<"div"> {
      * If `true`, hides dates that are out of the selectable range.
      */
     hideOutOfRangeDates?: boolean;
+    /**
+     * Locale for date formatting
+     */
+    locale?: any;
 }
 /**
  * Props for the Calendar component with single date selection.
  */
-export interface CalendarSingleProps extends CalendarBaseProps, UseCalendarSingleProps {
+export interface CalendarSingleProps<TDate extends DateFrameworkType> extends CalendarBaseProps, UseCalendarSingleProps<TDate> {
     /**
      * The selection variant, set to "single".
      */
@@ -25,7 +30,7 @@ export interface CalendarSingleProps extends CalendarBaseProps, UseCalendarSingl
 /**
  * Props for the Calendar component with date range selection.
  */
-export interface CalendarRangeProps extends CalendarBaseProps, UseCalendarRangeProps {
+export interface CalendarRangeProps<TDate extends DateFrameworkType> extends CalendarBaseProps, UseCalendarRangeProps<TDate> {
     /**
      * The selection variant, set to "range".
      */
@@ -34,7 +39,7 @@ export interface CalendarRangeProps extends CalendarBaseProps, UseCalendarRangeP
 /**
  * Props for the Calendar component with multi-select date selection.
  */
-export interface CalendarMultiSelectProps extends CalendarBaseProps, UseCalendarMultiSelectProps {
+export interface CalendarMultiSelectProps<TDate extends DateFrameworkType> extends CalendarBaseProps, UseCalendarMultiSelectProps<TDate> {
     /**
      * The selection variant, set to "multiselect".
      */
@@ -43,7 +48,7 @@ export interface CalendarMultiSelectProps extends CalendarBaseProps, UseCalendar
 /**
  * Props for the Calendar component with offset date selection.
  */
-export interface CalendarOffsetProps extends CalendarBaseProps, UseCalendarOffsetProps {
+export interface CalendarOffsetProps<TDate extends DateFrameworkType> extends CalendarBaseProps, UseCalendarOffsetProps<TDate> {
     /**
      * The selection variant, set to "offset".
      */
@@ -52,5 +57,5 @@ export interface CalendarOffsetProps extends CalendarBaseProps, UseCalendarOffse
 /**
  * Type representing the props for the Calendar component with various selection variants.
  */
-export declare type CalendarProps = CalendarSingleProps | CalendarRangeProps | CalendarMultiSelectProps | CalendarOffsetProps;
-export declare const Calendar: import("react").ForwardRefExoticComponent<CalendarProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare type CalendarProps<TDate extends DateFrameworkType> = CalendarSingleProps<TDate> | CalendarRangeProps<TDate> | CalendarMultiSelectProps<TDate> | CalendarOffsetProps<TDate>;
+export declare const Calendar: import("react").ForwardRefExoticComponent<CalendarProps<any> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/calendar/CalendarGrid.d.ts

@@ -0,0 +1,13 @@
+import { type ComponentPropsWithoutRef } from "react";
+import { type CalendarMonthProps } from "./internal/CalendarMonth";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
+/**
+ * Props for the CalendarGrid component.
+ */
+export interface CalendarGridProps<TDate extends DateFrameworkType> extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * Props getter to pass to each CalendarMonth element
+     */
+    getCalendarMonthProps?: (date: TDate) => Omit<CalendarMonthProps<TDate>, "date">;
+}
+export declare const CalendarGrid: import("react").ForwardRefExoticComponent<CalendarGridProps<any> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/calendar/CalendarNavigation.d.ts

@@ -1,29 +1,28 @@
 import { type ButtonProps, type DropdownProps } from "@salt-ds/core";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import { type ComponentPropsWithRef } from "react";
-import { type DateValue } from "@internationalized/date";
-declare type DateDropdownProps = DropdownProps<DateValue>;
 /**
  * Props for the CalendarNavigation component.
  */
-export interface CalendarNavigationProps extends ComponentPropsWithRef<"div"> {
+export interface CalendarNavigationProps<TDate extends DateFrameworkType> extends ComponentPropsWithRef<"div"> {
     /**
      * Props for the month dropdown component.
      */
-    MonthDropdownProps?: DateDropdownProps;
+    MonthDropdownProps?: DropdownProps<TDate>;
     /**
      * Props for the year dropdown component.
      */
-    YearDropdownProps?: DateDropdownProps;
+    YearDropdownProps?: DropdownProps<TDate>;
     /**
      * Callback fired when a month is selected.
      * @param event - The change event.
      */
-    onMonthSelect?: DateDropdownProps["onChange"];
+    onMonthSelect?: DropdownProps<TDate>["onChange"];
     /**
      * Callback fired when a year is selected.
      * @param event - The change event.
      */
-    onYearSelect?: DateDropdownProps["onChange"];
+    onYearSelect?: DropdownProps<TDate>["onChange"];
     /**
      * Callback fired when navigating to the next month.
      * @param event - The click event.
@@ -46,12 +45,11 @@ export interface CalendarNavigationProps extends ComponentPropsWithRef<"div"> {
      * Format the month dropdown values
      * @param date
      */
-    formatMonth?: (date: DateValue) => string;
+    formatMonth?: string;
     /**
      * Format the year dropdown values
      * @param date
      */
-    formatYear?: (date: DateValue) => string;
+    formatYear?: string;
 }
-export declare const CalendarNavigation: import("react").ForwardRefExoticComponent<Omit<CalendarNavigationProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
-export {};
+export declare const CalendarNavigation: import("react").ForwardRefExoticComponent<Omit<CalendarNavigationProps<any>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/calendar/CalendarWeekHeader.d.ts

@@ -1,5 +1,6 @@
 import { type ComponentPropsWithRef } from "react";
-export declare type CalendarWeekHeaderProps = ComponentPropsWithRef<"div"> & {
-    locale?: string;
-};
+/**
+ * Props for the CalendarWeekHeader component.
+ */
+export declare type CalendarWeekHeaderProps = ComponentPropsWithRef<"div"> & {};
 export declare const CalendarWeekHeader: import("react").ForwardRefExoticComponent<Omit<CalendarWeekHeaderProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/calendar/index.d.ts

@@ -1,8 +1,7 @@
 export * from "./Calendar";
 export * from "./CalendarNavigation";
 export * from "./CalendarWeekHeader";
-export * from "./CalendarDateGrid";
+export * from "./CalendarGrid";
 export * from "./useCalendarDay";
 export * from "./useCalendar";
 export * from "./useCalendarSelection";
-export * from "./formatDate";

package/dist-types/calendar/internal/CalendarContext.d.ts

@@ -1,8 +1,7 @@
-import type { useCalendar } from "../useCalendar";
-interface CalendarState {
-    state: ReturnType<typeof useCalendar>["state"];
-    helpers: ReturnType<typeof useCalendar>["helpers"];
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
+import type { UseCalendarReturn } from "../useCalendar";
+interface CalendarState<TDate extends DateFrameworkType> extends UseCalendarReturn<TDate> {
 }
-declare const CalendarContext: import("react").Context<CalendarState | null>;
-declare function useCalendarContext(): CalendarState;
+declare const CalendarContext: import("react").Context<CalendarState<any> | null>;
+declare function useCalendarContext<TDate extends DateFrameworkType>(): CalendarState<TDate>;
 export { CalendarContext, useCalendarContext };

package/dist-types/calendar/internal/CalendarDay.d.ts

@@ -1,15 +1,13 @@
-import type { DateValue } from "@internationalized/date";
 import { type TooltipProps } from "@salt-ds/core";
 import { type ComponentPropsWithRef, type ReactElement } from "react";
 import { type DayStatus } from "../useCalendarDay";
-import { formatDate as defaultFormatDate } from "./utils";
 export declare type DateFormatter = (day: Date) => string | undefined;
-export interface CalendarDayProps extends Omit<ComponentPropsWithRef<"button">, "children"> {
-    day: DateValue;
-    formatDate?: typeof defaultFormatDate;
-    renderDayContents?: (date: DateValue, status: DayStatus) => ReactElement;
+export interface CalendarDayProps<TDate> extends Omit<ComponentPropsWithRef<"button">, "children"> {
+    day: TDate;
+    format?: string;
+    renderDayContents?: (date: TDate, status: DayStatus) => ReactElement;
     status?: DayStatus;
-    month: DateValue;
+    month: TDate;
     TooltipProps?: Partial<TooltipProps>;
 }
-export declare const CalendarDay: import("react").ForwardRefExoticComponent<Omit<CalendarDayProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const CalendarDay: import("react").ForwardRefExoticComponent<Omit<CalendarDayProps<any>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/calendar/internal/CalendarMonth.d.ts

@@ -1,18 +1,17 @@
-import type { DateValue } from "@internationalized/date";
 import { type ComponentPropsWithRef } from "react";
 import { type CalendarDayProps } from "./CalendarDay";
-export interface CalendarMonthProps extends ComponentPropsWithRef<"div"> {
+export interface CalendarMonthProps<TDate> extends ComponentPropsWithRef<"div"> {
     /**
      * Month to render as selectable dates
      */
-    date: DateValue;
+    date: TDate;
     /**
      * Function to render the contents of a day.
      */
-    renderDayContents?: CalendarDayProps["renderDayContents"];
+    renderDayContents?: CalendarDayProps<TDate>["renderDayContents"];
     /**
      * Props for the tooltip component.
      */
-    TooltipProps?: CalendarDayProps["TooltipProps"];
+    TooltipProps?: CalendarDayProps<TDate>["TooltipProps"];
 }
-export declare const CalendarMonth: import("react").ForwardRefExoticComponent<Omit<CalendarMonthProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CalendarMonth: import("react").ForwardRefExoticComponent<Omit<CalendarMonthProps<any>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/calendar/internal/useFocusManagement.d.ts

@@ -1,8 +1,7 @@
-import { type DateValue } from "@internationalized/date";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import type { FocusEventHandler, KeyboardEventHandler, MouseEventHandler } from "react";
-export declare function useFocusManagement({ date, locale, }: {
-    date: DateValue;
-    locale: string;
+export declare function useFocusManagement<TDate extends DateFrameworkType>({ date, }: {
+    date: TDate;
 }): {
     handleClick: MouseEventHandler<HTMLButtonElement>;
     handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;

package/dist-types/calendar/internal/utils.d.ts

@@ -1,14 +1,10 @@
-import { type CalendarDate, type DateValue } from "@internationalized/date";
-export declare function formatDate(date: DateValue, locale: string, options?: Intl.DateTimeFormatOptions): string;
-export declare function getCalendar(locale: string): import("@internationalized/date").Calendar;
-declare type WeekdayFormat = Intl.DateTimeFormatOptions["weekday"];
-export declare function daysForLocale(weekday: WeekdayFormat, locale: string): string[];
-export declare function monthsForLocale(currentYear: DateValue, locale: string): (CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime)[];
-export declare function generateVisibleDays(currentMonth: DateValue, locale: string): {
-    date: DateValue;
+import type { DateFrameworkType, SaltDateAdapter } from "@salt-ds/date-adapters";
+export declare function daysOfWeek<TDate extends DateFrameworkType>(dateAdapter: SaltDateAdapter<TDate>, format: "long" | "short" | "narrow", locale?: any): string[];
+export declare function generateMonthsForYear<TDate extends DateFrameworkType>(dateAdapter: SaltDateAdapter<TDate>, currentYear: TDate): TDate[];
+export declare function generateVisibleDays<TDate extends DateFrameworkType>(dateAdapter: SaltDateAdapter<TDate>, currentMonth: TDate, locale?: any): {
+    date: TDate;
     dateOfMonth: number;
     isCurrentMonth: boolean;
 }[];
-export declare function monthDiff(a: DateValue, b: DateValue): number;
-export declare function generateDatesForMonth(date: DateValue): CalendarDate[];
-export {};
+export declare function monthDiff<TDate extends DateFrameworkType>(dateAdapter: SaltDateAdapter<TDate>, a: TDate, b: TDate): number;
+export declare function generateDatesForMonth<TDate extends DateFrameworkType>(dateAdapter: SaltDateAdapter<TDate>, date: TDate): TDate[];

package/dist-types/calendar/useCalendar.d.ts

@@ -1,67 +1,63 @@
-import { type DateValue } from "@internationalized/date";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import { type SyntheticEvent } from "react";
 import { type UseCalendarSelectionMultiSelectProps, type UseCalendarSelectionOffsetProps, type UseCalendarSelectionRangeProps, type UseCalendarSelectionSingleProps } from "./useCalendarSelection";
 /**
  * Interface representing the base properties UseCalendar hook.
  */
-interface UseCalendarBaseProps {
+interface UseCalendarBaseProps<TDate> {
     /**
      * The default visible month.
      */
-    defaultVisibleMonth?: DateValue;
+    defaultVisibleMonth?: TDate;
     /**
      * Callback fired when the visible month changes.
      * @param event - The synthetic event.
      * @param visibleMonth - The new visible month.
      */
-    onVisibleMonthChange?: (event: SyntheticEvent, visibleMonth: DateValue) => void;
+    onVisibleMonthChange?: (event: SyntheticEvent, visibleMonth: TDate) => void;
     /**
      * Function to determine if a day is unselectable.
      * @param date - The date to check.
      * @returns A string reason if the day is unselectable, otherwise `false` or `undefined`.
      */
-    isDayUnselectable?: (date: DateValue) => string | false | undefined;
+    isDayUnselectable?: (date: TDate) => string | false | undefined;
     /**
      * Function to determine if a day is highlighted.
      * @param date - The date to check.
      * @returns A string reason if the day is highlighted, otherwise `false` or `undefined`.
      */
-    isDayHighlighted?: (date: DateValue) => string | false | undefined;
+    isDayHighlighted?: (date: TDate) => string | false | undefined;
     /**
      * Function to determine if a day is disabled.
      * @param date - The date to check.
      * @returns A string reason if the day is disabled, otherwise `false` or `undefined`.
      */
-    isDayDisabled?: (date: DateValue) => string | false | undefined;
+    isDayDisabled?: (date: TDate) => string | false | undefined;
     /**
      * The currently visible month.
      */
-    visibleMonth?: DateValue;
+    visibleMonth?: TDate;
     /**
      * If `true`, hides dates that are out of the selectable range.
      */
     hideOutOfRangeDates?: boolean;
     /**
-     * The minimum selectable date.
-     */
-    minDate?: DateValue;
-    /**
-     * The maximum selectable date.
+     * Locale for date formatting
      */
-    maxDate?: DateValue;
+    locale?: any;
     /**
-     * The time zone used for date calculations.
+     * The minimum selectable date.
      */
-    timeZone?: string;
+    minDate?: TDate;
     /**
-     * The locale used for date formatting.
+     * The maximum selectable date.
      */
-    locale?: string;
+    maxDate?: TDate;
 }
 /**
  * UseCalendar hook props for a single date selection Calendar.
  */
-export interface UseCalendarSingleProps extends UseCalendarSelectionSingleProps, UseCalendarBaseProps {
+export interface UseCalendarSingleProps<TDate extends DateFrameworkType> extends UseCalendarSelectionSingleProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "single".
      */
@@ -70,7 +66,7 @@ export interface UseCalendarSingleProps extends UseCalendarSelectionSingleProps,
 /**
  * UseCalendar hook props for a date range selection Calendar.
  */
-export interface UseCalendarRangeProps extends UseCalendarSelectionRangeProps, UseCalendarBaseProps {
+export interface UseCalendarRangeProps<TDate extends DateFrameworkType> extends UseCalendarSelectionRangeProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "range".
      */
@@ -79,7 +75,7 @@ export interface UseCalendarRangeProps extends UseCalendarSelectionRangeProps, U
 /**
  * UseCalendar hook props for a multi-select Calendar.
  */
-export interface UseCalendarMultiSelectProps extends UseCalendarSelectionMultiSelectProps, UseCalendarBaseProps {
+export interface UseCalendarMultiSelectProps<TDate extends DateFrameworkType> extends UseCalendarSelectionMultiSelectProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "multiselect".
      */
@@ -88,7 +84,7 @@ export interface UseCalendarMultiSelectProps extends UseCalendarSelectionMultiSe
 /**
  * UseCalendar hook props for an offset date selection Calendar.
  */
-export interface UseCalendarOffsetProps extends UseCalendarSelectionOffsetProps, UseCalendarBaseProps {
+export interface UseCalendarOffsetProps<TDate extends DateFrameworkType> extends UseCalendarSelectionOffsetProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "offset".
      */
@@ -97,42 +93,198 @@ export interface UseCalendarOffsetProps extends UseCalendarSelectionOffsetProps,
 /**
  * UseCalendar hook props, wth the selection variant determining the return type of the date selection
  */
-export declare type UseCalendarProps = UseCalendarSingleProps | UseCalendarRangeProps | UseCalendarMultiSelectProps | UseCalendarOffsetProps;
-export declare function useCalendar(props: UseCalendarProps): {
+export declare type UseCalendarProps<TDate extends DateFrameworkType> = UseCalendarSingleProps<TDate> | UseCalendarRangeProps<TDate> | UseCalendarMultiSelectProps<TDate> | UseCalendarOffsetProps<TDate>;
+/**
+ * Represents the return type of the useCalendar hook.
+ *
+ * @template TDate - The type of the date object used in the calendar.
+ */
+export interface UseCalendarReturn<TDate extends DateFrameworkType> {
+    /**
+     * The state of the calendar.
+     */
     state: {
-        selectedDate: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | import("./useCalendarSelection").DateRangeSelection | import("./useCalendarSelection").MultipleDateSelection | null | undefined;
-        hoveredDate: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | null | undefined;
-        visibleMonth: DateValue;
-        focusedDate: DateValue | null;
-        minDate: DateValue | undefined;
-        maxDate: DateValue | undefined;
-        selectionVariant: "offset" | "range" | "single" | "multiselect";
-        hideOutOfRangeDates: boolean | undefined;
+        /**
+         * The currently visible month in the calendar.
+         */
+        visibleMonth: TDate;
+        /**
+         * The currently focused date in the calendar, or null if no date is focused.
+         */
+        focusedDate: TDate | null;
+        /**
+         * The locale used for date formatting.
+         */
+        locale: any;
+        /**
+         * The minimum selectable date in the calendar.
+         */
+        minDate: TDate;
+        /**
+         * The maximum selectable date in the calendar.
+         */
+        maxDate: TDate;
+        /**
+         * The selection variant of the calendar, indicating the type of selection allowed.
+         */
+        selectionVariant: "single" | "range" | "multiselect" | "offset";
+        /**
+         * Whether to hide dates that are out of the selectable range.
+         */
+        hideOutOfRangeDates?: boolean;
+        /**
+         * Whether the calendar is currently focused.
+         */
         calendarFocused: boolean;
-        timeZone: string;
-        locale: string;
+        /**
+         * Additional state properties from selectionManager.state.
+         */
+        [key: string]: any;
     };
+    /**
+     * Helper functions for interacting with the calendar.
+     */
     helpers: {
-        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement, Event>, newSelectedDate: DateValue) => void;
-        isSelected: (date: DateValue) => boolean;
-        setHoveredDate: (event: SyntheticEvent<Element, Event>, date: DateValue | null) => void;
-        isHovered: (date: DateValue) => boolean;
-        isSelectedSpan: (date: DateValue) => boolean;
-        isHoveredSpan: (date: DateValue) => boolean;
-        isSelectedStart: (date: DateValue) => boolean;
-        isSelectedEnd: (date: DateValue) => boolean;
-        isHoveredOffset: (date: DateValue) => boolean;
-        isDaySelectable: ((date: DateValue) => boolean) | undefined;
-        setVisibleMonth: (event: SyntheticEvent, newVisibleMonth: DateValue) => void;
-        setFocusedDate: (event: SyntheticEvent, date: DateValue) => void;
-        setCalendarFocused: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-        isDayUnselectable: (date: DateValue) => string | false | undefined;
-        isDayHighlighted: (date: DateValue) => string | false | undefined;
-        isDayDisabled: (date: DateValue) => string | false | undefined;
-        isDayVisible: (date: DateValue) => boolean;
-        isOutsideAllowedDates: (date: DateValue) => boolean | undefined;
-        isOutsideAllowedMonths: (date: DateValue) => boolean | undefined;
-        isOutsideAllowedYears: (date: DateValue) => boolean | undefined;
+        /**
+         * Sets the visible month in the calendar.
+         *
+         * @param event - The synthetic event triggering the change.
+         * @param newVisibleMonth - The new visible month to set.
+         */
+        setVisibleMonth: (event: SyntheticEvent, newVisibleMonth: TDate) => void;
+        /**
+         * Sets the focused date in the calendar.
+         *
+         * @param event - The synthetic event triggering the change.
+         * @param date - The new date to focus.
+         */
+        setFocusedDate: (event: SyntheticEvent, date: TDate) => void;
+        /**
+         * Sets whether the calendar is focused.
+         *
+         * @param focused - Whether the calendar should be focused.
+         */
+        setCalendarFocused: (focused: boolean) => void;
+        /**
+         * Determines if a day is unselectable.
+         *
+         * @param date - The date to check.
+         * @returns A string reason if the day is unselectable, otherwise `false` or `undefined`.
+         */
+        isDayUnselectable: (date: TDate) => string | false | undefined;
+        /**
+         * Determines if a day is highlighted.
+         *
+         * @param date - The date to check.
+         * @returns A string reason if the day is highlighted, otherwise `false` or `undefined`.
+         */
+        isDayHighlighted: (date: TDate) => string | false | undefined;
+        /**
+         * Determines if a day is disabled.
+         *
+         * @param date - The date to check.
+         * @returns A string reason if the day is disabled, otherwise `false` or `undefined`.
+         */
+        isDayDisabled: (date: TDate) => string | false | undefined;
+        /**
+         * Determines if a day is visible in the calendar.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the day is visible, otherwise `false`.
+         */
+        isDayVisible: (date: TDate) => boolean;
+        /**
+         * Determines if a date is outside the allowed date range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is outside the allowed range, otherwise `false`.
+         */
+        isOutsideAllowedDates: (date: TDate) => boolean;
+        /**
+         * Determines if a month is outside the allowed range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the month is outside the allowed range, otherwise `false`.
+         */
+        isOutsideAllowedMonths: (date: TDate) => boolean;
+        /**
+         * Determines if a year is outside the allowed range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the year is outside the allowed range, otherwise `false`.
+         */
+        isOutsideAllowedYears: (date: TDate) => boolean;
+        /**
+         * Sets the selected date in the calendar.
+         *
+         * @param event - The event triggering the change.
+         * @param newSelectedDate - The new date to select.
+         */
+        setSelectedDate: (event: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement, MouseEvent>, newSelectedDate: TDate) => void;
+        /**
+         * Determines if a date is selected.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is selected, otherwise `false`.
+         */
+        isSelected: (date: TDate) => boolean;
+        /**
+         * Sets the hovered date in the calendar.
+         *
+         * @param event - The event triggering the change.
+         * @param newHoveredDate - The new date to hover.
+         */
+        setHoveredDate: (event: SyntheticEvent, newHoveredDate: TDate | null) => void;
+        /**
+         * Determines if a date is part of a selected span.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is part of a selected span, otherwise `false`.
+         */
+        isSelectedSpan: (date: TDate) => boolean;
+        /**
+         * Determines if a date is part of a hovered span.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is part of a hovered span, otherwise `false`.
+         */
+        isHoveredSpan: (date: TDate) => boolean;
+        /**
+         * Determines if a date is the start of a selected range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is the start of a selected range, otherwise `false`.
+         */
+        isSelectedStart: (date: TDate) => boolean;
+        /**
+         * Determines if a date is the end of a selected range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is the end of a selected range, otherwise `false`.
+         */
+        isSelectedEnd: (date: TDate) => boolean;
+        /**
+         * Determines if a date is hovered.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is hovered, otherwise `false`.
+         */
+        isHovered: (date: TDate) => boolean;
+        /**
+         * Determines if a date is part of a hovered offset.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is part of a hovered offset, otherwise `false`.
+         */
+        isHoveredOffset: (date: TDate) => boolean;
+        /**
+         * Determines if a day is selectable.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the day is selectable, otherwise `false`.
+         */
+        isDaySelectable: (date: TDate) => boolean;
     };
-};
+}
+export declare function useCalendar<TDate extends DateFrameworkType>(props: UseCalendarProps<TDate>): UseCalendarReturn<TDate>;
 export {};

package/dist-types/calendar/useCalendarDay.d.ts

@@ -1,4 +1,4 @@
-import { type DateValue } from "@internationalized/date";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import { type RefObject } from "react";
 /**
  * Interface representing the status of a day in the Calendar.
@@ -40,21 +40,19 @@ export interface DayStatus {
 /**
  * UseCalendar hook props to return a calendar day's status
  */
-export interface useCalendarDayProps {
+export interface useCalendarDayProps<TDate> {
     /**
      * The date of the calendar day.
      */
-    date: DateValue;
+    date: TDate;
     /**
      * The month of the calendar day.
      */
-    month: DateValue;
+    month: TDate;
 }
-export declare function useCalendarDay({ date, month }: useCalendarDayProps, ref: RefObject<HTMLElement>): {
+export declare function useCalendarDay<TDate extends DateFrameworkType>(props: useCalendarDayProps<TDate>, ref: RefObject<HTMLElement>): {
     status: DayStatus;
     dayProps: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">;
     unselectableReason: string | false | undefined;
     highlightedReason: string | false | undefined;
-    locale: string;
-    timeZone: string;
 };