@btst/stack 1.4.1 → 1.5.1

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useAnimation.mjs

@@ -0,0 +1,174 @@
+import { useRef, useLayoutEffect } from 'react';
+import { Animation } from './UI.mjs';
+
+const asHtmlElement = (element) => {
+    if (element instanceof HTMLElement)
+        return element;
+    return null;
+};
+const queryMonthEls = (element) => [
+    ...(element.querySelectorAll("[data-animated-month]") ?? []),
+];
+const queryMonthEl = (element) => asHtmlElement(element.querySelector("[data-animated-month]"));
+const queryCaptionEl = (element) => asHtmlElement(element.querySelector("[data-animated-caption]"));
+const queryWeeksEl = (element) => asHtmlElement(element.querySelector("[data-animated-weeks]"));
+const queryNavEl = (element) => asHtmlElement(element.querySelector("[data-animated-nav]"));
+const queryWeekdaysEl = (element) => asHtmlElement(element.querySelector("[data-animated-weekdays]"));
+/**
+ * Handles animations for transitioning between months in the DayPicker
+ * component.
+ *
+ * @private
+ * @param rootElRef - A reference to the root element of the DayPicker
+ *   component.
+ * @param enabled - Whether animations are enabled.
+ * @param options - Configuration options for the animation, including class
+ *   names, months, focused day, and the date utility library.
+ */
+function useAnimation(rootElRef, enabled, { classNames, months, focused, dateLib, }) {
+    const previousRootElSnapshotRef = useRef(null);
+    const previousMonthsRef = useRef(months);
+    const animatingRef = useRef(false);
+    useLayoutEffect(() => {
+        // get previous months before updating the previous months ref
+        const previousMonths = previousMonthsRef.current;
+        // update previous months ref for next effect trigger
+        previousMonthsRef.current = months;
+        if (!enabled ||
+            !rootElRef.current ||
+            // safety check because the ref can be set to anything by consumers
+            !(rootElRef.current instanceof HTMLElement) ||
+            // validation required for the animation to work as expected
+            months.length === 0 ||
+            previousMonths.length === 0 ||
+            months.length !== previousMonths.length) {
+            return;
+        }
+        const isSameMonth = dateLib.isSameMonth(months[0].date, previousMonths[0].date);
+        const isAfterPreviousMonth = dateLib.isAfter(months[0].date, previousMonths[0].date);
+        const captionAnimationClass = isAfterPreviousMonth
+            ? classNames[Animation.caption_after_enter]
+            : classNames[Animation.caption_before_enter];
+        const weeksAnimationClass = isAfterPreviousMonth
+            ? classNames[Animation.weeks_after_enter]
+            : classNames[Animation.weeks_before_enter];
+        // get previous root element snapshot before updating the snapshot ref
+        const previousRootElSnapshot = previousRootElSnapshotRef.current;
+        // update snapshot for next effect trigger
+        const rootElSnapshot = rootElRef.current.cloneNode(true);
+        if (rootElSnapshot instanceof HTMLElement) {
+            // if this effect is triggered while animating, we need to clean up the new root snapshot
+            // to put it in the same state as when not animating, to correctly animate the next month change
+            const currentMonthElsSnapshot = queryMonthEls(rootElSnapshot);
+            currentMonthElsSnapshot.forEach((currentMonthElSnapshot) => {
+                if (!(currentMonthElSnapshot instanceof HTMLElement))
+                    return;
+                // remove the old month snapshots from the new root snapshot
+                const previousMonthElSnapshot = queryMonthEl(currentMonthElSnapshot);
+                if (previousMonthElSnapshot &&
+                    currentMonthElSnapshot.contains(previousMonthElSnapshot)) {
+                    currentMonthElSnapshot.removeChild(previousMonthElSnapshot);
+                }
+                // remove animation classes from the new month snapshots
+                const captionEl = queryCaptionEl(currentMonthElSnapshot);
+                if (captionEl) {
+                    captionEl.classList.remove(captionAnimationClass);
+                }
+                const weeksEl = queryWeeksEl(currentMonthElSnapshot);
+                if (weeksEl) {
+                    weeksEl.classList.remove(weeksAnimationClass);
+                }
+            });
+            previousRootElSnapshotRef.current = rootElSnapshot;
+        }
+        else {
+            previousRootElSnapshotRef.current = null;
+        }
+        if (animatingRef.current ||
+            isSameMonth ||
+            // skip animation if a day is focused because it can cause issues to the animation and is better for a11y
+            focused) {
+            return;
+        }
+        const previousMonthEls = previousRootElSnapshot instanceof HTMLElement
+            ? queryMonthEls(previousRootElSnapshot)
+            : [];
+        const currentMonthEls = queryMonthEls(rootElRef.current);
+        if (currentMonthEls?.every((el) => el instanceof HTMLElement) &&
+            previousMonthEls &&
+            previousMonthEls.every((el) => el instanceof HTMLElement)) {
+            animatingRef.current = true;
+            // set isolation to isolate to isolate the stacking context during animation
+            rootElRef.current.style.isolation = "isolate";
+            // set z-index to 1 to ensure the nav is clickable over the other elements being animated
+            const navEl = queryNavEl(rootElRef.current);
+            if (navEl) {
+                navEl.style.zIndex = "1";
+            }
+            currentMonthEls.forEach((currentMonthEl, index) => {
+                const previousMonthEl = previousMonthEls[index];
+                if (!previousMonthEl) {
+                    return;
+                }
+                // animate new displayed month
+                currentMonthEl.style.position = "relative";
+                currentMonthEl.style.overflow = "hidden";
+                const captionEl = queryCaptionEl(currentMonthEl);
+                if (captionEl) {
+                    captionEl.classList.add(captionAnimationClass);
+                }
+                const weeksEl = queryWeeksEl(currentMonthEl);
+                if (weeksEl) {
+                    weeksEl.classList.add(weeksAnimationClass);
+                }
+                // animate new displayed month end
+                const cleanUp = () => {
+                    animatingRef.current = false;
+                    if (rootElRef.current) {
+                        rootElRef.current.style.isolation = "";
+                    }
+                    if (navEl) {
+                        navEl.style.zIndex = "";
+                    }
+                    if (captionEl) {
+                        captionEl.classList.remove(captionAnimationClass);
+                    }
+                    if (weeksEl) {
+                        weeksEl.classList.remove(weeksAnimationClass);
+                    }
+                    currentMonthEl.style.position = "";
+                    currentMonthEl.style.overflow = "";
+                    if (currentMonthEl.contains(previousMonthEl)) {
+                        currentMonthEl.removeChild(previousMonthEl);
+                    }
+                };
+                // animate old displayed month
+                previousMonthEl.style.pointerEvents = "none";
+                previousMonthEl.style.position = "absolute";
+                previousMonthEl.style.overflow = "hidden";
+                previousMonthEl.setAttribute("aria-hidden", "true");
+                // hide the weekdays container of the old month and only the new one
+                const previousWeekdaysEl = queryWeekdaysEl(previousMonthEl);
+                if (previousWeekdaysEl) {
+                    previousWeekdaysEl.style.opacity = "0";
+                }
+                const previousCaptionEl = queryCaptionEl(previousMonthEl);
+                if (previousCaptionEl) {
+                    previousCaptionEl.classList.add(isAfterPreviousMonth
+                        ? classNames[Animation.caption_before_exit]
+                        : classNames[Animation.caption_after_exit]);
+                    previousCaptionEl.addEventListener("animationend", cleanUp);
+                }
+                const previousWeeksEl = queryWeeksEl(previousMonthEl);
+                if (previousWeeksEl) {
+                    previousWeeksEl.classList.add(isAfterPreviousMonth
+                        ? classNames[Animation.weeks_before_exit]
+                        : classNames[Animation.weeks_after_exit]);
+                }
+                currentMonthEl.insertBefore(previousMonthEl, currentMonthEl.firstChild);
+            });
+        }
+    });
+}
+
+export { useAnimation };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useCalendar.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+const React = require('react');
+const getDates = require('./helpers/getDates.cjs');
+const getDays = require('./helpers/getDays.cjs');
+const getDisplayMonths = require('./helpers/getDisplayMonths.cjs');
+const getInitialMonth = require('./helpers/getInitialMonth.cjs');
+const getMonths = require('./helpers/getMonths.cjs');
+const getNavMonth = require('./helpers/getNavMonth.cjs');
+const getNextMonth = require('./helpers/getNextMonth.cjs');
+const getPreviousMonth = require('./helpers/getPreviousMonth.cjs');
+const getWeeks = require('./helpers/getWeeks.cjs');
+const useControlledValue = require('./helpers/useControlledValue.cjs');
+
+/**
+ * Provides the calendar object to work with the calendar in custom components.
+ *
+ * @private
+ * @param props - The DayPicker props related to calendar configuration.
+ * @param dateLib - The date utility library instance.
+ * @returns The calendar object containing displayed days, weeks, months, and
+ *   navigation methods.
+ */
+function useCalendar(props, dateLib) {
+    const [navStart, navEnd] = getNavMonth.getNavMonths(props, dateLib);
+    const { startOfMonth, endOfMonth } = dateLib;
+    const initialMonth = getInitialMonth.getInitialMonth(props, navStart, navEnd, dateLib);
+    const [firstMonth, setFirstMonth] = useControlledValue.useControlledValue(initialMonth, 
+    // initialMonth is always computed from props.month if provided
+    props.month ? initialMonth : undefined);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: change the initial month when the time zone changes.
+    React.useEffect(() => {
+        const newInitialMonth = getInitialMonth.getInitialMonth(props, navStart, navEnd, dateLib);
+        setFirstMonth(newInitialMonth);
+    }, [props.timeZone]);
+    /** The months displayed in the calendar. */
+    // biome-ignore lint/correctness/useExhaustiveDependencies: We want to recompute only when specific props change.
+    const { months, weeks, days, previousMonth, nextMonth } = React.useMemo(() => {
+        const displayMonths = getDisplayMonths.getDisplayMonths(firstMonth, navEnd, { numberOfMonths: props.numberOfMonths }, dateLib);
+        const dates = getDates.getDates(displayMonths, props.endMonth ? endOfMonth(props.endMonth) : undefined, {
+            ISOWeek: props.ISOWeek,
+            fixedWeeks: props.fixedWeeks,
+            broadcastCalendar: props.broadcastCalendar,
+        }, dateLib);
+        const months = getMonths.getMonths(displayMonths, dates, {
+            broadcastCalendar: props.broadcastCalendar,
+            fixedWeeks: props.fixedWeeks,
+            ISOWeek: props.ISOWeek,
+            reverseMonths: props.reverseMonths,
+        }, dateLib);
+        const weeks = getWeeks.getWeeks(months);
+        const days = getDays.getDays(months);
+        const previousMonth = getPreviousMonth.getPreviousMonth(firstMonth, navStart, props, dateLib);
+        const nextMonth = getNextMonth.getNextMonth(firstMonth, navEnd, props, dateLib);
+        return {
+            months,
+            weeks,
+            days,
+            previousMonth,
+            nextMonth,
+        };
+    }, [
+        dateLib,
+        firstMonth.getTime(),
+        navEnd?.getTime(),
+        navStart?.getTime(),
+        props.disableNavigation,
+        props.broadcastCalendar,
+        props.endMonth?.getTime(),
+        props.fixedWeeks,
+        props.ISOWeek,
+        props.numberOfMonths,
+        props.pagedNavigation,
+        props.reverseMonths,
+    ]);
+    const { disableNavigation, onMonthChange } = props;
+    const isDayInCalendar = (day) => weeks.some((week) => week.days.some((d) => d.isEqualTo(day)));
+    const goToMonth = (date) => {
+        if (disableNavigation) {
+            return;
+        }
+        let newMonth = startOfMonth(date);
+        // if month is before start, use the first month instead
+        if (navStart && newMonth < startOfMonth(navStart)) {
+            newMonth = startOfMonth(navStart);
+        }
+        // if month is after endMonth, use the last month instead
+        if (navEnd && newMonth > startOfMonth(navEnd)) {
+            newMonth = startOfMonth(navEnd);
+        }
+        setFirstMonth(newMonth);
+        onMonthChange?.(newMonth);
+    };
+    const goToDay = (day) => {
+        // is this check necessary?
+        if (isDayInCalendar(day)) {
+            return;
+        }
+        goToMonth(day.date);
+    };
+    const calendar = {
+        months,
+        weeks,
+        days,
+        navStart,
+        navEnd,
+        previousMonth,
+        nextMonth,
+        goToMonth,
+        goToDay,
+    };
+    return calendar;
+}
+
+exports.useCalendar = useCalendar;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useCalendar.mjs

@@ -0,0 +1,113 @@
+import { useEffect, useMemo } from 'react';
+import { getDates } from './helpers/getDates.mjs';
+import { getDays } from './helpers/getDays.mjs';
+import { getDisplayMonths } from './helpers/getDisplayMonths.mjs';
+import { getInitialMonth } from './helpers/getInitialMonth.mjs';
+import { getMonths } from './helpers/getMonths.mjs';
+import { getNavMonths } from './helpers/getNavMonth.mjs';
+import { getNextMonth } from './helpers/getNextMonth.mjs';
+import { getPreviousMonth } from './helpers/getPreviousMonth.mjs';
+import { getWeeks } from './helpers/getWeeks.mjs';
+import { useControlledValue } from './helpers/useControlledValue.mjs';
+
+/**
+ * Provides the calendar object to work with the calendar in custom components.
+ *
+ * @private
+ * @param props - The DayPicker props related to calendar configuration.
+ * @param dateLib - The date utility library instance.
+ * @returns The calendar object containing displayed days, weeks, months, and
+ *   navigation methods.
+ */
+function useCalendar(props, dateLib) {
+    const [navStart, navEnd] = getNavMonths(props, dateLib);
+    const { startOfMonth, endOfMonth } = dateLib;
+    const initialMonth = getInitialMonth(props, navStart, navEnd, dateLib);
+    const [firstMonth, setFirstMonth] = useControlledValue(initialMonth, 
+    // initialMonth is always computed from props.month if provided
+    props.month ? initialMonth : undefined);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: change the initial month when the time zone changes.
+    useEffect(() => {
+        const newInitialMonth = getInitialMonth(props, navStart, navEnd, dateLib);
+        setFirstMonth(newInitialMonth);
+    }, [props.timeZone]);
+    /** The months displayed in the calendar. */
+    // biome-ignore lint/correctness/useExhaustiveDependencies: We want to recompute only when specific props change.
+    const { months, weeks, days, previousMonth, nextMonth } = useMemo(() => {
+        const displayMonths = getDisplayMonths(firstMonth, navEnd, { numberOfMonths: props.numberOfMonths }, dateLib);
+        const dates = getDates(displayMonths, props.endMonth ? endOfMonth(props.endMonth) : undefined, {
+            ISOWeek: props.ISOWeek,
+            fixedWeeks: props.fixedWeeks,
+            broadcastCalendar: props.broadcastCalendar,
+        }, dateLib);
+        const months = getMonths(displayMonths, dates, {
+            broadcastCalendar: props.broadcastCalendar,
+            fixedWeeks: props.fixedWeeks,
+            ISOWeek: props.ISOWeek,
+            reverseMonths: props.reverseMonths,
+        }, dateLib);
+        const weeks = getWeeks(months);
+        const days = getDays(months);
+        const previousMonth = getPreviousMonth(firstMonth, navStart, props, dateLib);
+        const nextMonth = getNextMonth(firstMonth, navEnd, props, dateLib);
+        return {
+            months,
+            weeks,
+            days,
+            previousMonth,
+            nextMonth,
+        };
+    }, [
+        dateLib,
+        firstMonth.getTime(),
+        navEnd?.getTime(),
+        navStart?.getTime(),
+        props.disableNavigation,
+        props.broadcastCalendar,
+        props.endMonth?.getTime(),
+        props.fixedWeeks,
+        props.ISOWeek,
+        props.numberOfMonths,
+        props.pagedNavigation,
+        props.reverseMonths,
+    ]);
+    const { disableNavigation, onMonthChange } = props;
+    const isDayInCalendar = (day) => weeks.some((week) => week.days.some((d) => d.isEqualTo(day)));
+    const goToMonth = (date) => {
+        if (disableNavigation) {
+            return;
+        }
+        let newMonth = startOfMonth(date);
+        // if month is before start, use the first month instead
+        if (navStart && newMonth < startOfMonth(navStart)) {
+            newMonth = startOfMonth(navStart);
+        }
+        // if month is after endMonth, use the last month instead
+        if (navEnd && newMonth > startOfMonth(navEnd)) {
+            newMonth = startOfMonth(navEnd);
+        }
+        setFirstMonth(newMonth);
+        onMonthChange?.(newMonth);
+    };
+    const goToDay = (day) => {
+        // is this check necessary?
+        if (isDayInCalendar(day)) {
+            return;
+        }
+        goToMonth(day.date);
+    };
+    const calendar = {
+        months,
+        weeks,
+        days,
+        navStart,
+        navEnd,
+        previousMonth,
+        nextMonth,
+        goToMonth,
+        goToDay,
+    };
+    return calendar;
+}
+
+export { useCalendar };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useDayPicker.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+const React = require('react');
+
+/** @ignore */
+const dayPickerContext = React.createContext(undefined);
+/**
+ * Provides access to the DayPicker context, which includes properties and
+ * methods to interact with the DayPicker component. This hook must be used
+ * within a custom component.
+ *
+ * @template T - Use this type to refine the returned context type with a
+ *   specific selection mode.
+ * @returns The context to work with DayPicker.
+ * @throws {Error} If the hook is used outside of a DayPicker provider.
+ * @group Hooks
+ * @see https://daypicker.dev/guides/custom-components
+ */
+function useDayPicker() {
+    const context = React.useContext(dayPickerContext);
+    if (context === undefined) {
+        throw new Error("useDayPicker() must be used within a custom component.");
+    }
+    return context;
+}
+
+exports.dayPickerContext = dayPickerContext;
+exports.useDayPicker = useDayPicker;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useDayPicker.mjs

@@ -0,0 +1,25 @@
+import { createContext, useContext } from 'react';
+
+/** @ignore */
+const dayPickerContext = createContext(undefined);
+/**
+ * Provides access to the DayPicker context, which includes properties and
+ * methods to interact with the DayPicker component. This hook must be used
+ * within a custom component.
+ *
+ * @template T - Use this type to refine the returned context type with a
+ *   specific selection mode.
+ * @returns The context to work with DayPicker.
+ * @throws {Error} If the hook is used outside of a DayPicker provider.
+ * @group Hooks
+ * @see https://daypicker.dev/guides/custom-components
+ */
+function useDayPicker() {
+    const context = useContext(dayPickerContext);
+    if (context === undefined) {
+        throw new Error("useDayPicker() must be used within a custom component.");
+    }
+    return context;
+}
+
+export { dayPickerContext, useDayPicker };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useFocus.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+const React = require('react');
+const calculateFocusTarget = require('./helpers/calculateFocusTarget.cjs');
+const getNextFocus = require('./helpers/getNextFocus.cjs');
+
+/**
+ * Manages focus behavior for the DayPicker component, including setting,
+ * moving, and blurring focus on calendar days.
+ *
+ * @template T - The type of DayPicker props.
+ * @param props - The DayPicker props.
+ * @param calendar - The calendar object containing the displayed days and
+ *   months.
+ * @param getModifiers - A function to retrieve modifiers for a given day.
+ * @param isSelected - A function to check if a date is selected.
+ * @param dateLib - The date utility library instance.
+ * @returns An object containing focus-related methods and the currently focused
+ *   day.
+ */
+function useFocus(props, calendar, getModifiers, isSelected, dateLib) {
+    const { autoFocus } = props;
+    const [lastFocused, setLastFocused] = React.useState();
+    const focusTarget = calculateFocusTarget.calculateFocusTarget(calendar.days, getModifiers, isSelected || (() => false), lastFocused);
+    const [focusedDay, setFocused] = React.useState(autoFocus ? focusTarget : undefined);
+    const blur = () => {
+        setLastFocused(focusedDay);
+        setFocused(undefined);
+    };
+    const moveFocus = (moveBy, moveDir) => {
+        if (!focusedDay)
+            return;
+        const nextFocus = getNextFocus.getNextFocus(moveBy, moveDir, focusedDay, calendar.navStart, calendar.navEnd, props, dateLib);
+        if (!nextFocus)
+            return;
+        if (props.disableNavigation) {
+            const isNextInCalendar = calendar.days.some((day) => day.isEqualTo(nextFocus));
+            if (!isNextInCalendar) {
+                return;
+            }
+        }
+        calendar.goToDay(nextFocus);
+        setFocused(nextFocus);
+    };
+    const isFocusTarget = (day) => {
+        return Boolean(focusTarget?.isEqualTo(day));
+    };
+    const useFocus = {
+        isFocusTarget,
+        setFocused,
+        focused: focusedDay,
+        blur,
+        moveFocus,
+    };
+    return useFocus;
+}
+
+exports.useFocus = useFocus;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useFocus.mjs

@@ -0,0 +1,56 @@
+import { useState } from 'react';
+import { calculateFocusTarget } from './helpers/calculateFocusTarget.mjs';
+import { getNextFocus } from './helpers/getNextFocus.mjs';
+
+/**
+ * Manages focus behavior for the DayPicker component, including setting,
+ * moving, and blurring focus on calendar days.
+ *
+ * @template T - The type of DayPicker props.
+ * @param props - The DayPicker props.
+ * @param calendar - The calendar object containing the displayed days and
+ *   months.
+ * @param getModifiers - A function to retrieve modifiers for a given day.
+ * @param isSelected - A function to check if a date is selected.
+ * @param dateLib - The date utility library instance.
+ * @returns An object containing focus-related methods and the currently focused
+ *   day.
+ */
+function useFocus(props, calendar, getModifiers, isSelected, dateLib) {
+    const { autoFocus } = props;
+    const [lastFocused, setLastFocused] = useState();
+    const focusTarget = calculateFocusTarget(calendar.days, getModifiers, isSelected || (() => false), lastFocused);
+    const [focusedDay, setFocused] = useState(autoFocus ? focusTarget : undefined);
+    const blur = () => {
+        setLastFocused(focusedDay);
+        setFocused(undefined);
+    };
+    const moveFocus = (moveBy, moveDir) => {
+        if (!focusedDay)
+            return;
+        const nextFocus = getNextFocus(moveBy, moveDir, focusedDay, calendar.navStart, calendar.navEnd, props, dateLib);
+        if (!nextFocus)
+            return;
+        if (props.disableNavigation) {
+            const isNextInCalendar = calendar.days.some((day) => day.isEqualTo(nextFocus));
+            if (!isNextInCalendar) {
+                return;
+            }
+        }
+        calendar.goToDay(nextFocus);
+        setFocused(nextFocus);
+    };
+    const isFocusTarget = (day) => {
+        return Boolean(focusTarget?.isEqualTo(day));
+    };
+    const useFocus = {
+        isFocusTarget,
+        setFocused,
+        focused: focusedDay,
+        blur,
+        moveFocus,
+    };
+    return useFocus;
+}
+
+export { useFocus };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useSelection.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const useMulti = require('./selection/useMulti.cjs');
+const useRange = require('./selection/useRange.cjs');
+const useSingle = require('./selection/useSingle.cjs');
+
+/**
+ * Determines the appropriate selection hook to use based on the selection mode
+ * and returns the corresponding selection object.
+ *
+ * @template T - The type of DayPicker props.
+ * @param props - The DayPicker props.
+ * @param dateLib - The date utility library instance.
+ * @returns The selection object for the specified mode, or `undefined` if no
+ *   mode is set.
+ */
+function useSelection(props, dateLib) {
+    const single = useSingle.useSingle(props, dateLib);
+    const multi = useMulti.useMulti(props, dateLib);
+    const range = useRange.useRange(props, dateLib);
+    switch (props.mode) {
+        case "single":
+            return single;
+        case "multiple":
+            return multi;
+        case "range":
+            return range;
+        default:
+            return undefined;
+    }
+}
+
+exports.useSelection = useSelection;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/useSelection.mjs

@@ -0,0 +1,31 @@
+import { useMulti } from './selection/useMulti.mjs';
+import { useRange } from './selection/useRange.mjs';
+import { useSingle } from './selection/useSingle.mjs';
+
+/**
+ * Determines the appropriate selection hook to use based on the selection mode
+ * and returns the corresponding selection object.
+ *
+ * @template T - The type of DayPicker props.
+ * @param props - The DayPicker props.
+ * @param dateLib - The date utility library instance.
+ * @returns The selection object for the specified mode, or `undefined` if no
+ *   mode is set.
+ */
+function useSelection(props, dateLib) {
+    const single = useSingle(props, dateLib);
+    const multi = useMulti(props, dateLib);
+    const range = useRange(props, dateLib);
+    switch (props.mode) {
+        case "single":
+            return single;
+        case "multiple":
+            return multi;
+        case "range":
+            return range;
+        default:
+            return undefined;
+    }
+}
+
+export { useSelection };