@salt-ds/date-components 0.0.0-snapshot-20260330155807

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

@@ -0,0 +1,33 @@
+import { type RenderPropsType, type TooltipProps } from "@salt-ds/core";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
+import { type ComponentPropsWithRef } from "react";
+import { type DayStatus } from "../useCalendarDay";
+export interface CalendarDayProps extends Omit<ComponentPropsWithRef<"button">, "children"> {
+    /**
+     * Day date
+     */
+    date: DateFrameworkType;
+    /**
+     * Format of date
+     */
+    format?: string;
+    /**
+     * Render prop to enable customisation of day button.
+     */
+    render?: RenderPropsType["render"];
+    /**
+     * Month being rendered
+     */
+    month: DateFrameworkType;
+    /**
+     * Additional Tooltip props
+     */
+    TooltipProps?: Partial<TooltipProps>;
+}
+export interface renderCalendarDayProps extends CalendarDayProps {
+    /**
+     * Status of day
+     */
+    status: DayStatus;
+}
+export declare const CalendarDay: import("react").ForwardRefExoticComponent<Omit<CalendarDayProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,14 @@
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
+import { type ComponentPropsWithRef } from "react";
+import { type CalendarDayProps } from "./CalendarDay";
+export interface CalendarMonthProps extends ComponentPropsWithRef<"div"> {
+    /**
+     * Month to render as selectable dates
+     */
+    date: DateFrameworkType;
+    /**
+     * Props for the CalendarDay component.
+     */
+    CalendarDayProps?: Partial<CalendarDayProps>;
+}
+export declare const CalendarMonth: import("react").ForwardRefExoticComponent<Omit<CalendarMonthProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,24 @@
+import type { DateFrameworkType, SaltDateAdapter } from "@salt-ds/date-adapters";
+export type AnnouncementType = "minFocusableDateExceeded" | "maxFocusableDateExceeded" | "dateSelected" | "visibleMonthChanged";
+export type AnnouncerMinMaxFocusState = Record<string, never>;
+export interface AnnouncerVisibleMonthState {
+    startVisibleMonth: DateFrameworkType;
+    endVisibleMonth: DateFrameworkType;
+}
+export interface AnnouncerRangeDateSelectedState {
+    multiselect: boolean;
+    selectedDate: Array<{
+        startDate?: DateFrameworkType;
+        endDate?: DateFrameworkType;
+    }> | {
+        startDate?: DateFrameworkType;
+        endDate?: DateFrameworkType;
+    } | null;
+}
+export interface AnnouncerSingleDateSelectedState {
+    multiselect: boolean;
+    selectedDate: DateFrameworkType | DateFrameworkType[] | null;
+}
+export type DateSelectionAnnouncerState = AnnouncerSingleDateSelectedState | AnnouncerRangeDateSelectedState | AnnouncerVisibleMonthState | AnnouncerMinMaxFocusState;
+export declare function createSingleSelectionAnnouncement(announcementType: AnnouncementType, state: DateSelectionAnnouncerState, dateAdapter: SaltDateAdapter): string | undefined;
+export declare function createRangeSelectionAnnouncement(announcementType: AnnouncementType, state: DateSelectionAnnouncerState, dateAdapter: SaltDateAdapter): string | undefined;

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

@@ -0,0 +1,9 @@
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
+import type { FocusEventHandler, KeyboardEventHandler, MouseEventHandler } from "react";
+export declare function useFocusManagement({ date }: {
+    date: DateFrameworkType;
+}): {
+    handleClick: MouseEventHandler<HTMLButtonElement>;
+    handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+    handleFocus: FocusEventHandler<HTMLButtonElement>;
+};

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

@@ -0,0 +1,6 @@
+import type { DateFrameworkType, SaltDateAdapter, Timezone } from "@salt-ds/date-adapters";
+export declare function daysOfWeek(dateAdapter: SaltDateAdapter, format: "long" | "short" | "narrow"): string[];
+export declare function generateMonthsForYear(dateAdapter: SaltDateAdapter, currentYear: DateFrameworkType): any[];
+export declare function generateVisibleDays(dateAdapter: SaltDateAdapter, currentMonth: DateFrameworkType, timezone: Timezone): any[];
+export declare function monthDiff(dateAdapter: SaltDateAdapter, a: DateFrameworkType, b: DateFrameworkType): number;
+export declare function generateDatesForMonth(dateAdapter: SaltDateAdapter, date: DateFrameworkType): DateFrameworkType[];

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

@@ -0,0 +1,335 @@
+import { type ResponsiveProp } from "@salt-ds/core";
+import type { DateFrameworkType, Timezone } from "@salt-ds/date-adapters";
+import { type SyntheticEvent } from "react";
+import { type UseCalendarSelectionMultiselectOffsetProps, type UseCalendarSelectionMultiselectRangeProps, type UseCalendarSelectionMultiselectSingleProps, type UseCalendarSelectionOffsetProps, type UseCalendarSelectionRangeProps, type UseCalendarSelectionSingleProps } from "./useCalendarSelection";
+import { type CreateAnnouncement } from "./useDateSelectionAnnouncer";
+/**
+ * Base properties for the UseCalendar hook.
+ */
+interface UseCalendarBaseProps {
+    /**
+     * Factory method for date selection live announcements or null to silence announcements
+     */
+    createAnnouncement?: CreateAnnouncement | null;
+    /**
+     * The default visible month.
+     */
+    defaultVisibleMonth?: DateFrameworkType;
+    /**
+     * The currently focused date in the calendar, or null if no date is focused.
+     */
+    focusedDate?: DateFrameworkType | null;
+    /**
+     * The currently hovered date.
+     */
+    hoveredDate?: DateFrameworkType | null;
+    /**
+     * Function to determine if a day is visible.
+     * @param date - The date to check.
+     * @returns `true` if the day is visible, otherwise `false`.
+     */
+    isDayVisible?: (date: DateFrameworkType) => boolean;
+    /**
+     * Ref to attach to the focused element, enabling focus to be controlled.
+     */
+    focusedDateRef?: React.MutableRefObject<HTMLElement | null>;
+    /**
+     * Callback fired when the focused date changes.
+     * @param event - The synthetic event, if user event triggered focus or null.
+     * @param date - The new focused date.
+     */
+    onFocusedDateChange?: (event: SyntheticEvent | null, date: DateFrameworkType | null) => void;
+    /**
+     * Callback fired when the hovered date changes.
+     * @param event - The synthetic event.
+     * @param hoveredDate - The new hovered date.
+     */
+    onHoveredDateChange?: (event: SyntheticEvent, hoveredDate: DateFrameworkType | null) => void;
+    /**
+     * Callback fired when the visible month changes.
+     * @param event - The synthetic event or null if triggered by code.
+     * @param visibleMonth - The new visible month.
+     */
+    onVisibleMonthChange?: (event: SyntheticEvent | null, visibleMonth: DateFrameworkType) => 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: DateFrameworkType) => 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: DateFrameworkType) => string | false | undefined;
+    /**
+     * If `true`, hides dates that are out of the selectable range.
+     */
+    hideOutOfRangeDates?: boolean;
+    /**
+     * The minimum selectable date.
+     */
+    minDate?: DateFrameworkType;
+    /**
+     * The maximum selectable date.
+     */
+    maxDate?: DateFrameworkType;
+    /**
+     * Number of visible months, maximum 12, defaults to 1.
+     */
+    numberOfVisibleMonths?: ResponsiveProp<1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12>;
+    /**
+     * Specifies the timezone behavior:
+     * - If undefined, the timezone will be derived from the passed date, or from `defaultSelectedDate`/`selectedDate`.
+     * - If set to "default", the default timezone of the date library will be used.
+     * - If set to "system", the local system's timezone will be applied.
+     * - If set to "UTC", the time will be returned in UTC.
+     * - If set to a valid IANA timezone identifier, the time will be returned for that specific timezone.
+     */
+    timezone?: Timezone;
+    /**
+     * The currently visible month.
+     */
+    visibleMonth?: DateFrameworkType;
+}
+/**
+ * UseCalendar hook props for a single date selection.
+ */
+export interface UseCalendarSingleProps extends UseCalendarSelectionSingleProps, UseCalendarBaseProps {
+}
+/**
+ * UseCalendar hook props for a multi-select, single date selection.
+ */
+export interface UseCalendarMultiselectSingleProps extends UseCalendarSelectionMultiselectSingleProps, Omit<UseCalendarBaseProps, "multiselect"> {
+}
+/**
+ * UseCalendar hook props for a date range selection.
+ */
+export interface UseCalendarRangeProps extends UseCalendarSelectionRangeProps, UseCalendarBaseProps {
+}
+/**
+ * UseCalendar hook props for a multi-select, date range selection.
+ */
+export interface UseCalendarMultiselectRangeProps extends UseCalendarSelectionMultiselectRangeProps, Omit<UseCalendarBaseProps, "multiselect"> {
+}
+/**
+ * UseCalendar hook props for an offset date selection.
+ */
+export interface UseCalendarOffsetProps extends UseCalendarSelectionOffsetProps, UseCalendarBaseProps {
+}
+/**
+ * UseCalendar hook props for a multi-select, offset selection.
+ */
+export interface UseCalendarMultiselectOffsetProps extends UseCalendarSelectionMultiselectOffsetProps, Omit<UseCalendarBaseProps, "multiselect"> {
+}
+/**
+ * UseCalendar hook props, wth the selection variant determining the return type of the date selection
+ */
+export type UseCalendarProps = UseCalendarSingleProps | UseCalendarMultiselectSingleProps | UseCalendarRangeProps | UseCalendarMultiselectRangeProps | UseCalendarOffsetProps | UseCalendarMultiselectOffsetProps;
+/**
+ * Represents the return type of the useCalendar hook.
+ */
+export interface UseCalendarReturn {
+    /**
+     * The state of the calendar.
+     */
+    state: {
+        /**
+         * The currently visible month in the calendar.
+         */
+        visibleMonth: DateFrameworkType;
+        /**
+         * The currently focused date in the calendar, or null if no date is focused.
+         */
+        focusedDate: DateFrameworkType | null;
+        /**
+         *  Focusable dates based on current state
+         */
+        focusableDate: DateFrameworkType | null;
+        /**
+         * Ref to attach to the focused element,enabling focus to be controlled.
+         */
+        focusedDateRef?: React.MutableRefObject<HTMLButtonElement | null>;
+        /**
+         * Multi-select variant of the calendar, indicating if multiple date selections are allowed.
+         */
+        multiselect: boolean;
+        /**
+         * The minimum selectable date in the calendar.
+         */
+        minDate: DateFrameworkType;
+        /**
+         * The maximum selectable date in the calendar.
+         */
+        maxDate: DateFrameworkType;
+        /**
+         * The selection variant of the calendar, indicating the type of selection allowed.
+         */
+        selectionVariant: "single" | "range" | "offset";
+        /**
+         * Whether to hide dates that are out of the selectable range.
+         */
+        hideOutOfRangeDates?: boolean;
+        /**
+         * Number of visible months
+         */
+        numberOfVisibleMonths: number;
+        /**
+         * Specifies the timezone behavior:
+         * - If undefined, the timezone will be derived from the passed date, or from `defaultSelectedDate`/`selectedDate`.
+         * - If set to "default", the default timezone of the date library will be used.
+         * - If set to "system", the local system's timezone will be applied.
+         * - If set to "UTC", the time will be returned in UTC.
+         * - If set to a valid IANA timezone identifier, the time will be returned for that specific timezone.
+         */
+        timezone?: Timezone;
+    };
+    /**
+     * Helper functions for interacting with the calendar.
+     */
+    helpers: {
+        /**
+         * Sets the visible month in the calendar.
+         *
+         * @param event - The synthetic event or null if triggered by code.
+         * @param newVisibleMonth - The new visible month to set.
+         */
+        setVisibleMonth: (event: SyntheticEvent | null, newVisibleMonth: DateFrameworkType) => void;
+        /**
+         * Sets the focused date in the calendar.
+         *
+         * @param event - The synthetic event or null if triggered by code.
+         * @param date - The new date to focus.
+         */
+        setFocusedDate: (event: SyntheticEvent | null, date: DateFrameworkType | null) => 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: DateFrameworkType) => 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: DateFrameworkType) => 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: DateFrameworkType) => boolean;
+        /**
+         * Determines if a date is outside the allowed date range.
+         *
+         * @param date - The date to check.
+         * * @returns -1 if before the allowed range, 0 if inside, 1 if after.
+         */
+        isOutsideAllowedDates: (date: DateFrameworkType) => -1 | 0 | 1;
+        /**
+         * 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: DateFrameworkType) => 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: DateFrameworkType) => boolean;
+        /**
+         * Determines if the date range is on the same day
+         *
+         * @param date - The range to check.
+         * @returns `true` if the range start and end date are the same
+         */
+        isSameDay: (date: DateFrameworkType) => 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: DateFrameworkType) => void;
+        /**
+         * Determines if a date is selected.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is selected, otherwise `false`.
+         */
+        isSelected: (date: DateFrameworkType) => boolean;
+        /**
+         * Determines if a date is hovered.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is hovered, otherwise `false`.
+         */
+        isHovered: (date: DateFrameworkType) => 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: DateFrameworkType | 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: DateFrameworkType) => 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: DateFrameworkType) => 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: DateFrameworkType) => boolean;
+        /**
+         * Determines if the hovered and a new date range would be created, if selected.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is the start of a hovered offset, otherwise `false`.
+         */
+        isHoveredStart: (date: DateFrameworkType) => boolean;
+        /**
+         * Determines if a date is part of a hovered range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is part of a hovered offset, otherwise `false`.
+         */
+        isHoveredSpan: (date: DateFrameworkType) => boolean;
+        /**
+         * Determines if the hovered and a date range would be completed, if selected.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is the end of a hovered offset, otherwise `false`.
+         */
+        isHoveredEnd: (date: DateFrameworkType) => boolean;
+        /**
+         * Determines if a day is selectable.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the day is selectable, otherwise `false`.
+         */
+        isDaySelectable: (date: DateFrameworkType) => boolean;
+    };
+}
+export declare function useCalendar(props: UseCalendarProps): UseCalendarReturn;
+export {};

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

@@ -0,0 +1,67 @@
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
+import type { ComponentPropsWithoutRef } from "react";
+/**
+ * Interface representing the status of a day in the Calendar.
+ */
+export interface DayStatus {
+    /**
+     * If `true`, the day is selectable but outside of current month.
+     */
+    outOfRange?: boolean;
+    /**
+     * If `true`, the day is selected.
+     */
+    selected?: boolean;
+    /**
+     * If `true`, the day is selected.
+     */
+    selectedStart?: boolean;
+    /**
+     * If `true`, the day is selected.
+     */
+    selectedSpan?: boolean;
+    /**
+     * If `true`, the day is selected.
+     */
+    selectedEnd?: boolean;
+    /**
+     * If `true`, the day is today.
+     */
+    today?: boolean;
+    /**
+     * If set, the day is unselectable with a reason.
+     */
+    unselectable?: string | false;
+    /**
+     * If set, the day is highlighted with a reason.
+     */
+    highlighted?: string | false;
+    /**
+     * If `true`, the day is focused.
+     */
+    focused?: boolean;
+    /**
+     * If `true`, the day is hidden.
+     */
+    hidden?: boolean;
+}
+/**
+ * UseCalendar hook props to return a calendar day's status
+ */
+export interface useCalendarDayProps {
+    /**
+     * The date of the calendar day.
+     */
+    date: DateFrameworkType;
+    /**
+     * The month of the calendar day.
+     */
+    month: DateFrameworkType;
+}
+export declare function useCalendarDay(props: useCalendarDayProps): {
+    status: DayStatus;
+    dayProps: ComponentPropsWithoutRef<"button">;
+    focusedDateRef: import("react").MutableRefObject<HTMLButtonElement | null> | null | undefined;
+    unselectableReason: string | false | undefined;
+    highlightedReason: string | false | undefined;
+};

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

@@ -0,0 +1,145 @@
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
+import { type KeyboardEventHandler, type MouseEventHandler, type SyntheticEvent } from "react";
+/**
+ * Type representing a single date selection.
+ */
+export type SingleDateSelection<TDate extends DateFrameworkType = DateFrameworkType> = TDate;
+/**
+ * Type representing a date range selection.
+ * @template TDate - The type of the date object.
+ */
+export type DateRangeSelection<TDate extends DateFrameworkType = DateFrameworkType> = {
+    /**
+     * The start date of the range, or null if empty
+     */
+    startDate?: TDate | null;
+    /**
+     * The end date of the range, or null if empty
+     */
+    endDate?: TDate | null;
+};
+/**
+ * Checks if a value is a date range selection.
+ * @template TDate - The type of the date object.
+ * @param value - The value to check.
+ * @returns `true` if the value is a date range selection, otherwise `false`.
+ */
+export declare function isDateRangeSelection<TDate extends DateFrameworkType = DateFrameworkType>(value: unknown): value is DateRangeSelection<TDate>;
+export type SelectionVariant = "single" | "range" | "offset";
+/**
+ * Base properties for calendar UseCalendarSelection hook.
+ */
+export interface UseCalendarSelectionBaseProps<Selection> {
+    /**
+     * Determines if a date is outside the allowed date range.
+     * @param date - The date to check.
+     * @returns 0 if inside the date range, -1 if before the min date, 1 if after the max date.
+     */
+    isOutsideAllowedDates?: (date: DateFrameworkType) => -1 | 0 | 1;
+    /**
+     * Function to determine if a day is selectable.
+     * @param date - The date to check.
+     * @returns `true` if the day is selectable, otherwise `false`.
+     */
+    isDaySelectable?: (date: DateFrameworkType) => boolean;
+    /**
+     * If `true`, the calendar will be multiselect.
+     */
+    multiselect?: boolean;
+    /**
+     * The selection variant, set to "single".
+     */
+    selectionVariant: SelectionVariant;
+    /**
+     * The currently selected date.
+     */
+    selectedDate?: Selection;
+    /**
+     * The default selected date.
+     */
+    defaultSelectedDate?: Selection;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param selectedDate - The new selected date.
+     */
+    onSelectionChange?: (event: SyntheticEvent, selectedDate: Selection) => void;
+    /**
+     * A pure function to manage the selected date for uncontrolled use-cases.
+     * Return the selection based on the previous selection and the new date.
+     * @param previousSelectedDate
+     * @param newDate
+     */
+    select?: (previousSelectedDate: Selection, newDate: DateFrameworkType) => Selection;
+    /**
+     * Function to calculate the start date offset.
+     * @param date - The date to offset.
+     * @returns The offset start date.
+     */
+    startDateOffset?: (date: DateFrameworkType) => DateFrameworkType;
+    /**
+     * Function to calculate the end date offset.
+     * @param date - The date to offset.
+     * @returns The offset end date.
+     */
+    endDateOffset?: (date: DateFrameworkType) => DateFrameworkType;
+}
+export type UseCalendarSelectionSingleProps = UseCalendarSelectionBaseProps<SingleDateSelection<DateFrameworkType> | null> & {
+    selectionVariant: "single";
+    multiselect?: false;
+};
+export type UseCalendarSelectionMultiselectSingleProps = UseCalendarSelectionBaseProps<Array<SingleDateSelection<DateFrameworkType>>> & {
+    selectionVariant: "single";
+    multiselect: true;
+};
+export type UseCalendarSelectionRangeProps = UseCalendarSelectionBaseProps<DateRangeSelection<DateFrameworkType>> & {
+    selectionVariant: "range";
+    multiselect?: false;
+};
+export type UseCalendarSelectionMultiselectRangeProps = UseCalendarSelectionBaseProps<Array<DateRangeSelection<DateFrameworkType>>> & {
+    selectionVariant: "range";
+    multiselect: true;
+};
+export type UseCalendarSelectionOffsetProps = UseCalendarSelectionBaseProps<DateRangeSelection<DateFrameworkType>> & {
+    selectionVariant: "offset";
+    multiselect?: false;
+};
+export type UseCalendarSelectionMultiselectOffsetProps = UseCalendarSelectionBaseProps<Array<DateRangeSelection<DateFrameworkType>>> & {
+    selectionVariant: "offset";
+    multiselect: true;
+};
+export type UseCalendarSelectionProps = UseCalendarSelectionSingleProps | UseCalendarSelectionMultiselectSingleProps | UseCalendarSelectionRangeProps | UseCalendarSelectionMultiselectRangeProps | UseCalendarSelectionOffsetProps | UseCalendarSelectionMultiselectOffsetProps;
+export declare function useCalendarSelection(props: UseCalendarSelectionProps): {
+    state: {
+        selectedDate: any;
+    };
+    helpers: {
+        isSelected: (date: DateFrameworkType) => boolean;
+        isSameDay: (date: DateFrameworkType) => boolean;
+        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement>, newSelectedDate: DateFrameworkType) => void;
+        isSelectedStart: (date: DateFrameworkType) => boolean;
+        isSelectedSpan: (date: DateFrameworkType) => boolean;
+        isSelectedEnd: (date: DateFrameworkType) => boolean;
+    };
+};
+export declare function useCalendarSelectionDay({ date }: {
+    date: DateFrameworkType;
+}): {
+    handleClick: MouseEventHandler<HTMLButtonElement>;
+    handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+    status: {
+        hovered: boolean;
+        selected: boolean;
+        selectedStart: boolean;
+        selectedSpan: boolean;
+        selectedEnd: boolean;
+        hoveredStart: boolean;
+        hoveredSpan: boolean;
+        hoveredEnd: boolean;
+    };
+    dayProps: {
+        className: string;
+        "aria-disabled": string | undefined;
+        "aria-label": string;
+    };
+};

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

@@ -0,0 +1,6 @@
+import type { SaltDateAdapter } from "@salt-ds/date-adapters";
+import type { AnnouncementType, DateSelectionAnnouncerState } from "./internal/createAnnouncement";
+export type CreateAnnouncement = (announcementType: AnnouncementType, state: DateSelectionAnnouncerState, dateAdapter: SaltDateAdapter) => string | undefined;
+export declare function useDateSelectionAnnouncer(createAnnouncement: CreateAnnouncement | null | undefined, dateAdapter: SaltDateAdapter): {
+    announce: (announcementType: AnnouncementType, state?: DateSelectionAnnouncerState | undefined) => void;
+};