@codecademy/gamut 68.2.3-alpha.df0cb3.0 → 68.2.3-alpha.e3cc4a.0

package/dist/DatePicker/DatePicker.js

@@ -1,155 +0,0 @@
-import { MiniArrowRightIcon } from '@codecademy/gamut-icons';
-import { useCallback, useId, useMemo, useRef, useState } from 'react';
-import { Box, FlexBox } from '../Box';
-import { PopoverContainer } from '../PopoverContainer';
-import { DatePickerCalendar } from './DatePickerCalendar';
-import { DatePickerProvider } from './DatePickerContext';
-import { DatePickerInput } from './DatePickerInput';
-import { isRangeProps } from './utils/dateSelect';
-import { useResolvedLocale } from './utils/locale';
-import { DEFAULT_DATE_PICKER_TRANSLATIONS } from './utils/translations';
-
-/**
- * DatePicker: single-date or range. Holds shared state and provides it via context.
- * Single: selectedDate, setSelectedDate. Range: startDate, endDate, setStartDate, setEndDate.
- * With no children, renders default layout (input + calendar popover).
- */
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-export const DatePicker = props => {
-  const {
-    locale,
-    disabledDates = [],
-    placeholder,
-    mode,
-    children,
-    translations: translationsProp,
-    inputSize
-  } = props;
-  const [isCalendarOpen, setIsCalendarOpen] = useState(false);
-  const [focusGridSignal, setFocusGridSignal] = useState(false);
-  const [gridFocusRequested, setGridFocusRequested] = useState(false);
-  const [activeRangePart, setActiveRangePart] = useState(null);
-  const inputRef = useRef(null);
-  const dialogId = useId();
-  const calendarDialogId = `datepicker-dialog-${dialogId.replace(/:/g, '')}`;
-  const clearGridFocusRequest = useCallback(() => {
-    setGridFocusRequested(false);
-  }, []);
-  const resolvedLocale = useResolvedLocale(locale);
-  const openCalendar = useCallback(options => {
-    const moveFocus = options?.moveFocusIntoCalendar ?? false;
-    setIsCalendarOpen(true);
-    if (moveFocus) {
-      setGridFocusRequested(true);
-      setFocusGridSignal(signal => !signal);
-    } else {
-      setGridFocusRequested(false);
-    }
-  }, []);
-  const focusCalendarGrid = useCallback(() => {
-    setGridFocusRequested(true);
-    setFocusGridSignal(signal => !signal);
-  }, []);
-  const closeCalendar = useCallback(() => {
-    setIsCalendarOpen(false);
-    setActiveRangePart(null);
-    setGridFocusRequested(false);
-    inputRef.current?.focus();
-  }, []);
-  const startOrSelectedDate = isRangeProps(props) ? props.startDate : props.selectedDate;
-  const endDate = isRangeProps(props) ? props.endDate : null;
-  const setSelection = useCallback((start, end) => {
-    if (isRangeProps(props)) {
-      props.setStartDate(start);
-      props.setEndDate(end ?? null);
-    } else {
-      props.setSelectedDate(start);
-    }
-  }, [props]);
-  const contextValue = useMemo(() => {
-    const translations = {
-      ...DEFAULT_DATE_PICKER_TRANSLATIONS,
-      ...translationsProp
-    };
-    const base = {
-      startOrSelectedDate,
-      setSelection,
-      isCalendarOpen,
-      openCalendar,
-      focusCalendarGrid,
-      focusGridSignal,
-      gridFocusRequested,
-      clearGridFocusRequest,
-      closeCalendar,
-      locale: resolvedLocale,
-      disabledDates,
-      calendarDialogId,
-      translations
-    };
-    return mode === 'range' ? {
-      ...base,
-      mode: 'range',
-      endDate,
-      activeRangePart,
-      setActiveRangePart
-    } : {
-      ...base,
-      mode: 'single'
-    };
-  }, [mode, startOrSelectedDate, endDate, setSelection, activeRangePart, setActiveRangePart, isCalendarOpen, openCalendar, focusCalendarGrid, focusGridSignal, gridFocusRequested, clearGridFocusRequest, closeCalendar, resolvedLocale, disabledDates, calendarDialogId, translationsProp]);
-  const content = children !== undefined ? children : /*#__PURE__*/_jsxs(_Fragment, {
-    children: [/*#__PURE__*/_jsx(FlexBox, {
-      gap: inputSize === 'small' ? 4 : 8,
-      width: "fit-content",
-      children: mode === 'range' ? /*#__PURE__*/_jsxs(_Fragment, {
-        children: [/*#__PURE__*/_jsx(DatePickerInput, {
-          label: props.startLabel,
-          placeholder: placeholder,
-          rangePart: "start",
-          ref: inputRef,
-          size: inputSize
-        }), /*#__PURE__*/_jsx(Box, {
-          alignSelf: "center",
-          mt: 32,
-          children: /*#__PURE__*/_jsx(MiniArrowRightIcon, {})
-        }), /*#__PURE__*/_jsx(DatePickerInput, {
-          label: props.endLabel,
-          placeholder: placeholder,
-          rangePart: "end",
-          size: inputSize
-          // does this need a ref?
-        })]
-      }) : /*#__PURE__*/_jsx(DatePickerInput, {
-        label: props.label,
-        placeholder: placeholder,
-        ref: inputRef,
-        size: inputSize
-      })
-    }), /*#__PURE__*/_jsx(PopoverContainer, {
-      alignment: "bottom-left",
-      allowPageInteraction: true,
-      focusOnProps: {
-        autoFocus: false,
-        focusLock: false
-      },
-      invertAxis: "x",
-      isOpen: isCalendarOpen,
-      targetRef: inputRef,
-      x: -20,
-      y: -16,
-      onRequestClose: closeCalendar,
-      children: /*#__PURE__*/_jsx("div", {
-        "aria-label": contextValue.translations.calendarDialogAriaLabel,
-        id: calendarDialogId,
-        role: "dialog",
-        children: /*#__PURE__*/_jsx(DatePickerCalendar, {
-          dialogId: calendarDialogId
-        })
-      })
-    })]
-  });
-  return /*#__PURE__*/_jsx(DatePickerProvider, {
-    value: contextValue,
-    children: content
-  });
-};

package/dist/DatePicker/DatePickerCalendar.d.ts

@@ -1,11 +0,0 @@
-import type { CalendarBodyProps } from './Calendar/types';
-export type DatePickerCalendarProps = Pick<CalendarBodyProps, 'weekStartsOn'> & {
-    /** id for the dialog (for aria-controls from input). */
-    dialogId: string;
-};
-/**
- * Calendar that composes Calendar, CalendarHeader, CalendarBody, CalendarFooter.
- * When inside DatePicker: owns local visibleDate and focusedDate; updates shared
- * state via context. Supports single-date and range modes.
- */
-export declare const DatePickerCalendar: React.FC<DatePickerCalendarProps>;

package/dist/DatePicker/DatePickerCalendar.js

@@ -1,163 +0,0 @@
-import { breakpoints } from '@codecademy/gamut-styles';
-import { useEffect, useId, useMemo, useRef, useState } from 'react';
-import { useMedia } from 'react-use';
-import { Box, FlexBox } from '../Box';
-import { CalendarBody, CalendarFooter, CalendarHeader, CalendarWrapper } from './Calendar';
-import { useDatePicker } from './DatePickerContext';
-import { handleDateSelectRange, handleDateSelectSingle } from './utils/dateSelect';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * Calendar that composes Calendar, CalendarHeader, CalendarBody, CalendarFooter.
- * When inside DatePicker: owns local visibleDate and focusedDate; updates shared
- * state via context. Supports single-date and range modes.
- */
-export const DatePickerCalendar = ({
-  dialogId,
-  weekStartsOn
-}) => {
-  const context = useDatePicker();
-  const generatedId = useId();
-  const fallbackDialogId = `datepicker-calendar-${generatedId.replace(/:/g, '')}`;
-  const headingId = dialogId ?? context?.calendarDialogId ?? fallbackDialogId;
-  if (context == null) {
-    throw new Error('DatePickerCalendar must be used inside a DatePicker (it reads shared state from context).');
-  }
-  const {
-    mode,
-    startOrSelectedDate,
-    setSelection,
-    disabledDates,
-    locale,
-    closeCalendar,
-    isCalendarOpen,
-    translations,
-    focusGridSignal,
-    gridFocusRequested,
-    clearGridFocusRequest
-  } = context;
-  const focusGridSync = useMemo(() => ({
-    gridFocusRequested,
-    signal: focusGridSignal,
-    onGridFocusRequestHandled: clearGridFocusRequest
-  }), [gridFocusRequested, focusGridSignal, clearGridFocusRequest]);
-  const isRange = mode === 'range';
-  const endDate = isRange ? context.endDate : undefined;
-  const firstOfMonth = date => new Date(date.getFullYear(), date.getMonth(), 1);
-  const [displayDate, setDisplayDate] = useState(() => firstOfMonth(startOrSelectedDate ?? new Date()));
-  const [focusedDate, setFocusedDate] = useState(() => startOrSelectedDate ?? endDate ?? new Date());
-  const wasOpenRef = useRef(false);
-
-  // Sync visible month to selection only when the calendar opens, not on every
-  // date click. Otherwise clicking a date in the second month would jump the view.
-  useEffect(() => {
-    const justOpened = isCalendarOpen && !wasOpenRef.current;
-    wasOpenRef.current = isCalendarOpen;
-    if (!justOpened) return;
-    const anchor = startOrSelectedDate ?? endDate;
-    if (anchor) {
-      setDisplayDate(firstOfMonth(anchor));
-      setFocusedDate(startOrSelectedDate ?? endDate ?? new Date());
-    }
-  }, [isCalendarOpen, startOrSelectedDate, endDate]);
-  const onDateSelect = date => {
-    if (!isRange) {
-      handleDateSelectSingle({
-        date,
-        selectedDate: startOrSelectedDate,
-        setSelection
-      });
-    } else {
-      context.setActiveRangePart(null);
-      handleDateSelectRange({
-        date,
-        activeRangePart: context.activeRangePart,
-        startDate: startOrSelectedDate,
-        endDate: context.endDate,
-        setSelection,
-        disabledDates
-      });
-    }
-  };
-  const handleClearDate = () => {
-    setSelection(null);
-    setFocusedDate(displayDate);
-  };
-  const handleTodayClick = () => {
-    const today = new Date();
-    setSelection(today);
-    setDisplayDate(firstOfMonth(today));
-    setFocusedDate(today);
-  };
-  const focusTarget = focusedDate ?? startOrSelectedDate ?? endDate ?? new Date();
-  const addMonths = (date, n) => new Date(date.getFullYear(), date.getMonth() + n, 1);
-  const secondMonthDate = addMonths(displayDate, 1);
-  const isTwoMonthsVisible = useMedia(`(min-width: ${breakpoints.xs})`);
-  return /*#__PURE__*/_jsxs(CalendarWrapper, {
-    children: [/*#__PURE__*/_jsxs(FlexBox, {
-      p: 24,
-      pb: 16,
-      children: [/*#__PURE__*/_jsxs(Box, {
-        children: [/*#__PURE__*/_jsx(CalendarHeader, {
-          displayDate: displayDate,
-          headingId: headingId,
-          hideNextNav: isTwoMonthsVisible,
-          locale: locale,
-          onDisplayDateChange: setDisplayDate
-        }), /*#__PURE__*/_jsx(CalendarBody, {
-          disabledDates: disabledDates,
-          displayDate: displayDate,
-          endDate: endDate,
-          focusGridSync: focusGridSync,
-          focusedDate: focusTarget,
-          hasAdjacentMonthRight: isTwoMonthsVisible,
-          labelledById: headingId,
-          locale: locale,
-          selectedDate: startOrSelectedDate,
-          weekStartsOn: weekStartsOn,
-          onDateSelect: onDateSelect,
-          onDisplayDateChange: setDisplayDate,
-          onEscapeKeyPress: closeCalendar,
-          onFocusedDateChange: setFocusedDate
-        })]
-      }), /*#__PURE__*/_jsxs(Box, {
-        display: {
-          _: 'none',
-          xs: 'initial'
-        },
-        pl: {
-          _: 0,
-          xs: 32
-        },
-        children: [/*#__PURE__*/_jsx(CalendarHeader, {
-          displayDate: secondMonthDate,
-          headingId: headingId,
-          hideLastNav: true,
-          locale: locale,
-          onDisplayDateChange: setDisplayDate
-        }), /*#__PURE__*/_jsx(CalendarBody, {
-          disabledDates: disabledDates,
-          displayDate: secondMonthDate,
-          endDate: endDate,
-          focusGridSync: focusGridSync,
-          focusedDate: focusTarget,
-          hasAdjacentMonthLeft: isTwoMonthsVisible,
-          labelledById: headingId,
-          locale: locale,
-          selectedDate: startOrSelectedDate,
-          weekStartsOn: weekStartsOn,
-          onDateSelect: onDateSelect,
-          onDisplayDateChange: setDisplayDate,
-          onEscapeKeyPress: closeCalendar,
-          onFocusedDateChange: setFocusedDate
-        })]
-      })]
-    }), /*#__PURE__*/_jsx(CalendarFooter, {
-      clearText: translations.clearText,
-      disabled: startOrSelectedDate === null && endDate === null,
-      locale: locale,
-      showClearButton: isRange,
-      onClearDate: handleClearDate,
-      onTodayClick: handleTodayClick
-    })]
-  });
-};

package/dist/DatePicker/DatePickerContext.d.ts

@@ -1,10 +0,0 @@
-import type { DatePickerContextValue as DatePickerContextValueType } from './types';
-export declare const DatePickerContext: import("react").Context<DatePickerContextValueType | null>;
-/** Provider component; DatePicker uses this to set the context value. */
-export declare const DatePickerProvider: import("react").Provider<DatePickerContextValueType | null>;
-/**
- * Returns the DatePicker context value (shared state and callbacks).
- * Must be used inside a DatePicker. For composed layouts, use this to get
- * openCalendar, closeCalendar, isCalendarOpen, inputRef, calendarDialogId, etc.
- */
-export declare const useDatePicker: () => DatePickerContextValueType;

package/dist/DatePicker/DatePickerContext.js

@@ -1,18 +0,0 @@
-import { createContext, useContext } from 'react';
-export const DatePickerContext = /*#__PURE__*/createContext(null);
-
-/** Provider component; DatePicker uses this to set the context value. */
-export const DatePickerProvider = DatePickerContext.Provider;
-
-/**
- * Returns the DatePicker context value (shared state and callbacks).
- * Must be used inside a DatePicker. For composed layouts, use this to get
- * openCalendar, closeCalendar, isCalendarOpen, inputRef, calendarDialogId, etc.
- */
-export const useDatePicker = () => {
-  const value = useContext(DatePickerContext);
-  if (value == null) {
-    throw new Error('useDatePickerContext must be used within a DatePicker.');
-  }
-  return value;
-};

package/dist/DatePicker/DatePickerInput.d.ts

@@ -1,16 +0,0 @@
-import { ComponentProps } from 'react';
-import { Input } from '../Form/inputs/Input';
-/**
- * Props for DatePickerInput. When used inside DatePicker, only overrides (e.g. placeholder, label).
- * In range mode, use rangePart to bind to start or end date. When outside DatePicker, pass value, onChange, etc.
- */
-export type DatePickerInputProps = Omit<ComponentProps<typeof Input>, 'type' | 'icon'> & {
-    /** In range mode: which part of the range this input edits. Omit for single-date or combined display. */
-    rangePart?: 'start' | 'end';
-};
-/**
- * Date input. When inside DatePicker: owns local input value state and syncs to
- * shared selectedDate via context on blur/parse; opens calendar on click/arrow down.
- * When outside DatePicker: fully controlled by props.
- */
-export declare const DatePickerInput: import("react").ForwardRefExoticComponent<Omit<DatePickerInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;

package/dist/DatePicker/DatePickerInput.js

@@ -1,134 +0,0 @@
-import { MiniCalendarIcon } from '@codecademy/gamut-icons';
-import { forwardRef, useEffect, useId, useRef, useState } from 'react';
-import { FormGroup } from '../Form/elements/FormGroup';
-import { Input } from '../Form/inputs/Input';
-import { formatDateForInput, getDateFormatPattern, parseDateFromInput } from './Calendar/utils/format';
-import { useDatePicker } from './DatePickerContext';
-
-/**
- * Props for DatePickerInput. When used inside DatePicker, only overrides (e.g. placeholder, label).
- * In range mode, use rangePart to bind to start or end date. When outside DatePicker, pass value, onChange, etc.
- */
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * Date input. When inside DatePicker: owns local input value state and syncs to
- * shared selectedDate via context on blur/parse; opens calendar on click/arrow down.
- * When outside DatePicker: fully controlled by props.
- */
-export const DatePickerInput = /*#__PURE__*/forwardRef(({
-  placeholder,
-  label,
-  rangePart,
-  ...rest
-}, ref) => {
-  const context = useDatePicker();
-  if (context == null) {
-    throw new Error('DatePickerInput must be used inside a DatePicker (it reads shared state from context).');
-  }
-  const {
-    mode,
-    startOrSelectedDate,
-    setSelection,
-    openCalendar,
-    focusCalendarGrid,
-    locale,
-    isCalendarOpen,
-    calendarDialogId,
-    translations
-  } = context;
-  const isRange = mode === 'range';
-  const inputID = useId();
-  const inputId = `datepicker-input-${inputID.replace(/:/g, '')}`;
-
-  // Range with two inputs: each input binds to one part. Single or range combined: one value.
-  const boundDate = isRange && rangePart === 'end' ? context.endDate : startOrSelectedDate;
-  const formattedValue = boundDate != null ? formatDateForInput(boundDate, locale) : '';
-  const [inputValue, setInputValue] = useState(() => formattedValue);
-  const isInputFocusedRef = useRef(false);
-
-  // Sync input from shared state. Skip when focused so we don't overwrite while typing.
-  useEffect(() => {
-    if (!isInputFocusedRef.current) {
-      setInputValue(formattedValue);
-    }
-  }, [formattedValue]);
-
-  /** Apply raw input string to selection state. Returns formatted string if parsed so caller can sync input (e.g. on blur). */
-  const applyValueToSelection = raw => {
-    const trimmed = raw.trim();
-    if (!trimmed) {
-      if (isRange && rangePart) {
-        if (rangePart === 'start') setSelection(null, context.endDate);else setSelection(startOrSelectedDate, null);
-      } else setSelection(null);
-      return undefined;
-    }
-    const parsed = parseDateFromInput(trimmed, locale);
-    if (!parsed) return undefined;
-    if (isRange && rangePart) {
-      if (rangePart === 'start') setSelection(parsed, context.endDate);else setSelection(startOrSelectedDate, parsed);
-    } else setSelection(parsed);
-    return formatDateForInput(parsed, locale);
-  };
-  const handleChange = e => {
-    const raw = e.target.value;
-    setInputValue(raw);
-    applyValueToSelection(raw);
-  };
-  const handleBlur = () => {
-    isInputFocusedRef.current = false;
-    const formatted = applyValueToSelection(inputValue.trim());
-    if (formatted) setInputValue(formatted);else if (inputValue.trim()) setInputValue(formattedValue);
-  };
-  const handleKeyDown = e => {
-    if (e.key === 'ArrowDown' || e.key === 'Down') {
-      e.preventDefault();
-      if (isCalendarOpen) {
-        focusCalendarGrid();
-      } else {
-        openCalendar({
-          moveFocusIntoCalendar: true
-        });
-      }
-    }
-  };
-  const handleOpenCalendar = () => {
-    openCalendar({
-      moveFocusIntoCalendar: false
-    });
-  };
-  const defaultLabel = !isRange ? translations.dateLabel : rangePart === 'end' ? translations.endDateLabel : translations.startDateLabel;
-  return /*#__PURE__*/_jsx(FormGroup, {
-    htmlFor: inputId,
-    isSoloField: true // should probaly be based on a prop
-    ,
-    label: label ?? defaultLabel,
-    mb: 0,
-    pb: 0,
-    spacing: "tight",
-    width: "170px",
-    children: /*#__PURE__*/_jsx(Input, {
-      ...rest,
-      "aria-autocomplete": "none",
-      "aria-controls": calendarDialogId,
-      "aria-expanded": isCalendarOpen,
-      "aria-haspopup": "dialog",
-      icon: () => /*#__PURE__*/_jsx(MiniCalendarIcon, {
-        size: 16
-      }),
-      id: inputId,
-      placeholder: placeholder ?? getDateFormatPattern(locale),
-      ref: ref,
-      role: "combobox",
-      type: "text",
-      value: inputValue,
-      onBlur: handleBlur,
-      onChange: handleChange,
-      onClick: handleOpenCalendar,
-      onFocus: () => {
-        isInputFocusedRef.current = true;
-        if (isRange && rangePart) context.setActiveRangePart(rangePart);
-      },
-      onKeyDown: handleKeyDown
-    })
-  });
-});

package/dist/DatePicker/index.d.ts

@@ -1,5 +0,0 @@
-export * from './DatePicker';
-export * from './DatePickerContext';
-export * from './DatePickerCalendar';
-export * from './DatePickerInput';
-export type { IsoWeekday } from './utils/locale';

package/dist/DatePicker/index.js

@@ -1,5 +0,0 @@
-export * from './DatePicker';
-export * from './DatePickerContext';
-export * from './DatePickerCalendar';
-export * from './DatePickerInput';
-export {};

package/dist/DatePicker/types.d.ts

@@ -1,86 +0,0 @@
-import { ComponentProps } from 'react';
-import { Input } from '../Form/inputs/Input';
-import { CalendarBaseProps } from './Calendar/types';
-import { DatePickerTranslations } from './utils/translations';
-export interface DatePickerBaseProps extends Pick<CalendarBaseProps, 'locale' | 'disabledDates'> {
-    /** When provided, only the provider is rendered and children compose Input + Calendar. */
-    children?: React.ReactNode;
-    /** Placeholder for the input. */
-    placeholder?: string;
-    /** Override UI strings (e.g. clear button). Merged with defaults. */
-    translations?: DatePickerTranslations;
-    inputSize?: ComponentProps<typeof Input>['size'];
-}
-export interface DatePickerSingleProps extends DatePickerBaseProps {
-    mode?: 'single';
-    /** Controlled selected date. */
-    selectedDate: Date | null;
-    /** Called when the user selects a date. */
-    setSelectedDate: (date: Date | null) => void;
-    /** Label for the input. */
-    label?: string;
-}
-export interface DatePickerRangeProps extends DatePickerBaseProps {
-    mode: 'range';
-    /** Controlled start date. */
-    startDate: Date | null;
-    /** Controlled end date. */
-    endDate: Date | null;
-    /** Called when the user changes the start date. */
-    setStartDate: (date: Date | null) => void;
-    /** Called when the user changes the end date. */
-    setEndDate: (date: Date | null) => void;
-    /** Label for the start date input. */
-    startLabel?: string;
-    /** Label for the end date input. */
-    endLabel?: string;
-}
-export type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;
-export type OpenCalendarOptions = {
-    /**
-     * When true, move DOM focus into the date grid after open (keyboard / explicit request).
-     * When false (default), keep focus on the input so pointer users can type (WCAG 3.2.1).
-     */
-    moveFocusIntoCalendar?: boolean;
-};
-export interface DatePickerBaseContextValue extends Pick<CalendarBaseProps, 'disabledDates'> {
-    /**
-     * Resolved `Intl.Locale` from the `locale` prop (or runtime default). Same instance passed to
-     * formatters and available for `getWeekInfo()` etc.
-     */
-    locale: Intl.Locale;
-    isCalendarOpen: boolean;
-    openCalendar: (options?: OpenCalendarOptions) => void;
-    /** Move focus from the input into the grid when the calendar is already open (e.g. ArrowDown). */
-    focusCalendarGrid: () => void;
-    /**
-     * Flips on each grid focus request so `CalendarBody` effects re-run when `focusTarget` is unchanged.
-     * Not a semantic true/false — only the change matters; pair with `gridFocusRequested`.
-     */
-    focusGridSignal: boolean;
-    /** When true, `CalendarBody` runs a one-shot move of DOM focus into the grid if it is not already there. */
-    gridFocusRequested: boolean;
-    /** Clears `gridFocusRequested` after focus has moved into the grid (or call when closing). */
-    clearGridFocusRequest: () => void;
-    closeCalendar: () => void;
-    calendarDialogId: string;
-    /** UI string overrides (e.g. clear button). */
-    translations: Required<DatePickerTranslations>;
-    /** Start date (range) or selected date (single). */
-    startOrSelectedDate: Date | null;
-    /** Set selection. Single: (date). Range: (start, end). */
-    setSelection: (startOrSelectedDate: Date | null, endDate?: Date | null) => void;
-}
-export interface DatePickerSingleContextValue extends DatePickerBaseContextValue {
-    mode: 'single';
-}
-export type ActiveRangePart = 'start' | 'end' | null;
-export interface DatePickerRangeContextValue extends DatePickerBaseContextValue {
-    mode: 'range';
-    endDate: Date | null;
-    /** Which input is active (start/end focused); null = selection mode. */
-    activeRangePart: ActiveRangePart;
-    /** Set which input is active (e.g. when input receives focus). */
-    setActiveRangePart: (part: ActiveRangePart) => void;
-}
-export type DatePickerContextValue = DatePickerSingleContextValue | DatePickerRangeContextValue;

package/dist/DatePicker/types.js

@@ -1 +0,0 @@
-export {};

package/dist/DatePicker/utils/dateSelect.d.ts

@@ -1,19 +0,0 @@
-import type { DatePickerBaseContextValue, DatePickerProps, DatePickerRangeContextValue, DatePickerRangeProps } from '../types';
-export declare const isRangeProps: (props: DatePickerProps) => props is DatePickerRangeProps;
-export type RangeContainsDisabledParams = {
-    start: Date;
-    end: Date;
-    disabledDates: Date[];
-};
-/** True if any disabled date falls within [start, end] (inclusive, by calendar day). */
-export declare const rangeContainsDisabled: ({ start, end, disabledDates, }: RangeContainsDisabledParams) => boolean;
-export type HandleDateSelectSingleParams = {
-    date: Date;
-    selectedDate: DatePickerBaseContextValue['startOrSelectedDate'];
-} & Pick<DatePickerBaseContextValue, 'setSelection'>;
-export declare const handleDateSelectSingle: ({ date, selectedDate, setSelection, }: HandleDateSelectSingleParams) => void;
-export type HandleDateSelectRangeParams = {
-    date: Date;
-    startDate: DatePickerRangeContextValue['startOrSelectedDate'];
-} & Pick<DatePickerRangeContextValue, 'activeRangePart' | 'endDate' | 'setSelection' | 'disabledDates'>;
-export declare const handleDateSelectRange: ({ date, activeRangePart, startDate, endDate, setSelection, disabledDates, }: HandleDateSelectRangeParams) => void;