@flikk/ui 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/components/forms/DateRangePicker/DateRangePicker.js

@@ -0,0 +1,110 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import React__default, { createContext, useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { dateRangePickerTheme } from './DateRangePicker.theme.js';
+import { DEFAULT_DATE_RANGE_PRESETS } from './dateRangePresets.js';
+import { FormLabel } from '../FormLabel/FormLabel.js';
+import { DateRangePickerTrigger } from './DateRangePickerTrigger.js';
+import { DateRangePickerBody } from './DateRangePickerBody.js';
+import { DateRangePickerPresets } from './DateRangePickerPresets.js';
+import { cn } from '../../../utils/cn.js';
+import { formatDateCustom } from '../../../utils/dateUtils.js';
+
+const DateRangePickerContext = createContext(undefined);
+/**
+ * Format date for display
+ */
+const formatDate = (date, formatString, options = {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+}) => {
+    if (formatString) {
+        return formatDateCustom(date, formatString);
+    }
+    return date.toLocaleDateString(undefined, options);
+};
+/**
+ * Format date range for display
+ */
+const formatDateRange = (range, formatString, options) => {
+    if (!range.start && !range.end)
+        return "";
+    if (range.start && !range.end)
+        return formatDate(range.start, formatString, options);
+    if (!range.start && range.end)
+        return formatDate(range.end, formatString, options);
+    return `${formatDate(range.start, formatString, options)} - ${formatDate(range.end, formatString, options)}`;
+};
+/**
+ * DateRangePicker Component — dedicated range picker with presets and dual calendars
+ */
+const DateRangePickerComponent = React__default.forwardRef(({ id, name, size = "md", state = "default", value, defaultValue, placeholder = "Select date range...", disabled = false, required = false, label, helperText, onChange, onFocus, onBlur, presets = DEFAULT_DATE_RANGE_PRESETS, showPresets = true, minDate, maxDate, isDateDisabled, showToday = true, weekdays, months, dateFormat, formatString, yearRange, className = "", wrapperClassName = "", portal = true, placement = "bottom-start", offset = 4, ...rest }, ref) => {
+    var _a, _b;
+    const theme = { ...dateRangePickerTheme };
+    const [isOpen, setIsOpen] = useState(false);
+    const [selectedRange, setSelectedRange] = useState(value || defaultValue);
+    const triggerRef = useRef(null);
+    const contentRef = useRef(null);
+    // Sync controlled value
+    useEffect(() => {
+        if (value !== undefined) {
+            setSelectedRange(value);
+        }
+    }, [value]);
+    const handleRangeSelect = useCallback((newRange) => {
+        setSelectedRange(newRange);
+        onChange === null || onChange === void 0 ? void 0 : onChange(newRange);
+    }, [onChange]);
+    const handleButtonClick = useCallback(() => {
+        if (!disabled) {
+            setIsOpen((prev) => !prev);
+        }
+    }, [disabled]);
+    const displayValue = selectedRange
+        ? formatDateRange(selectedRange, formatString, dateFormat)
+        : placeholder;
+    const generatedId = React__default.useId();
+    const pickerId = id || generatedId;
+    return (jsx(DateRangePickerContext.Provider, { value: useMemo(() => ({
+            isOpen,
+            setIsOpen,
+            selectedRange,
+            handleRangeSelect,
+            minDate,
+            maxDate,
+            isDateDisabled,
+            showToday,
+            weekdays,
+            months,
+            yearRange,
+            size,
+            state,
+            theme,
+            triggerRef,
+            contentRef,
+        }), [
+            isOpen,
+            selectedRange,
+            handleRangeSelect,
+            minDate,
+            maxDate,
+            isDateDisabled,
+            showToday,
+            weekdays,
+            months,
+            yearRange,
+            size,
+            state,
+            theme,
+        ]), children: jsxs("div", { ref: ref, className: cn(theme.containerStyle, wrapperClassName), ...rest, children: [label && (jsx(FormLabel, { htmlFor: pickerId, required: required, children: label })), jsx(DateRangePickerTrigger, { id: pickerId, disabled: disabled, isOpen: isOpen, state: state, size: size, onClick: handleButtonClick, onFocus: onFocus, onBlur: onBlur, className: className, children: jsx("span", { className: cn("block truncate", selectedRange && (selectedRange.start || selectedRange.end)
+                            ? theme.valueTextStyle
+                            : theme.placeholderTextStyle), children: displayValue }) }), jsx(DateRangePickerBody, { isOpen: isOpen, onClose: () => setIsOpen(false), portal: portal, placement: placement, offset: offset, presets: presets, showPresets: showPresets }), helperText && (jsx("p", { className: cn(theme.helperTextStyle, theme.helperTextStates[state]), children: helperText })), name && selectedRange && (jsxs(Fragment, { children: [jsx("input", { type: "hidden", name: `${name}[start]`, value: ((_a = selectedRange.start) === null || _a === void 0 ? void 0 : _a.toISOString()) || "" }), jsx("input", { type: "hidden", name: `${name}[end]`, value: ((_b = selectedRange.end) === null || _b === void 0 ? void 0 : _b.toISOString()) || "" })] }))] }) }));
+});
+DateRangePickerComponent.displayName = "DateRangePicker";
+// Compound component
+const DateRangePickerWithCompounds = DateRangePickerComponent;
+DateRangePickerWithCompounds.Trigger = DateRangePickerTrigger;
+DateRangePickerWithCompounds.Body = DateRangePickerBody;
+DateRangePickerWithCompounds.Presets = DateRangePickerPresets;
+
+export { DateRangePickerWithCompounds as DateRangePicker, DateRangePickerBody, DateRangePickerContext, DateRangePickerPresets, DateRangePickerTrigger };

package/dist/components/forms/DateRangePicker/DateRangePicker.theme.d.ts

@@ -0,0 +1,5 @@
+import { DateRangePickerTheme } from "./DateRangePicker.types";
+/**
+ * DateRangePicker theme — mirrors DatePicker theme with added checkmark style
+ */
+export declare const dateRangePickerTheme: DateRangePickerTheme;

package/dist/components/forms/DateRangePicker/DateRangePicker.theme.js

@@ -0,0 +1,52 @@
+import { formsBaseTheme } from '../forms.theme.js';
+
+/**
+ * DateRangePicker theme — mirrors DatePicker theme with added checkmark style
+ */
+const dateRangePickerTheme = {
+    containerStyle: formsBaseTheme.wrapperStyle,
+    baseStyle: formsBaseTheme.inputGroupBaseStyle + " justify-between cursor-pointer",
+    triggerButtonStyle: "w-full cursor-pointer bg-white dark:bg-[var(--color-neutral-900)]",
+    placeholderTextStyle: "text-[var(--color-text-placeholder)]",
+    valueTextStyle: "text-[var(--color-text-primary)]",
+    triggerSizes: {
+        sm: `${formsBaseTheme.sizes.sm.text} ${formsBaseTheme.sizes.sm.padding} ${formsBaseTheme.sizes.sm.height}`,
+        md: `${formsBaseTheme.sizes.md.text} ${formsBaseTheme.sizes.md.padding} ${formsBaseTheme.sizes.md.height}`,
+        lg: `${formsBaseTheme.sizes.lg.text} ${formsBaseTheme.sizes.lg.padding} ${formsBaseTheme.sizes.lg.height}`,
+    },
+    triggerStates: formsBaseTheme.states,
+    triggerHoverStates: formsBaseTheme.hoverStates,
+    triggerFocusStates: formsBaseTheme.focusStates,
+    iconEndStyle: formsBaseTheme.iconStyles.right,
+    iconEndPadding: formsBaseTheme.iconStyles.padding.right,
+    bodyStyle: "flex flex-col sm:flex-row w-fit max-w-[calc(100vw-2rem)] sm:max-w-none bg-white border border-[var(--color-border)] rounded-[var(--popover-radius)] shadow-lg p-0 overflow-hidden z-[1000] fixed " +
+        "dark:bg-[var(--color-neutral-900)] dark:border-[var(--color-neutral-700)]",
+    presetsContainerStyle: "hidden sm:flex flex-col gap-1 p-3 sm:border-r border-[var(--color-border)] bg-[var(--color-neutral-50)] sm:min-w-[180px] " +
+        "dark:bg-[var(--color-neutral-800)] ",
+    presetButtonStyle: "w-full text-left px-3 py-2 text-base font-medium rounded-[calc(var(--radius-base)*0.75)] transition-colors cursor-pointer " +
+        "flex items-center justify-between gap-2 " +
+        "text-[var(--color-text-secondary)] hover:bg-white hover:text-[var(--color-text-primary)] " +
+        "focus:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-primary)] focus-visible:ring-offset-2 " +
+        "data-[active=true]:bg-white data-[active=true]:text-[var(--color-text-primary)] data-[active=true]:font-medium " +
+        "dark:hover:bg-[var(--color-neutral-700)] " +
+        "dark:data-[active=true]:bg-[var(--color-neutral-700)] dark:data-[active=true]:text-[var(--color-neutral-100)] " +
+        "dark:focus-visible:ring-offset-[var(--color-neutral-800)]",
+    presetCheckmarkStyle: "size-4 text-[var(--color-primary)] shrink-0",
+    mobilePresetsContainerStyle: "sm:hidden px-3 pt-3 pb-1",
+    mobilePresetButtonStyle: "whitespace-nowrap px-3 py-1.5 text-sm font-medium rounded-full transition-colors cursor-pointer shrink-0 " +
+        "bg-[var(--color-background-secondary)] text-[var(--color-text-secondary)] " +
+        "hover:bg-[var(--color-background-tertiary)] hover:text-[var(--color-text-primary)] " +
+        "data-[active=true]:bg-[var(--color-primary-50)] data-[active=true]:text-[var(--color-primary)] " +
+        "dark:bg-[var(--color-neutral-800)] dark:text-[var(--color-neutral-300)] " +
+        "dark:hover:bg-[var(--color-neutral-700)] " +
+        "dark:data-[active=true]:bg-[var(--color-primary-950)] dark:data-[active=true]:text-[var(--color-primary-300)]",
+    mobileRangeDisplayStyle: "sm:hidden text-sm text-center py-2 text-[var(--color-text-secondary)] dark:text-[var(--color-neutral-400)]",
+    helperTextStyle: formsBaseTheme.helperText,
+    helperTextStates: {
+        default: "text-[var(--color-text-muted)] dark:text-[var(--color-neutral-400)]",
+        disabled: "text-[var(--color-text-disabled)] dark:text-[var(--color-neutral-600)]",
+        invalid: "text-[var(--color-danger)] dark:text-[var(--color-danger-400)]",
+    },
+};
+
+export { dateRangePickerTheme };

package/dist/components/forms/DateRangePicker/DateRangePicker.types.d.ts

@@ -0,0 +1,154 @@
+import React from "react";
+import type { DateRange } from "../../core/Calendar/Calendar.types";
+export type { DateRange };
+/**
+ * Size variants for DateRangePicker
+ */
+export type DateRangePickerSize = "sm" | "md" | "lg";
+/**
+ * State variants for DateRangePicker
+ */
+export type DateRangePickerState = "default" | "disabled" | "invalid";
+/**
+ * Placement options for DateRangePicker popover
+ */
+export type DateRangePickerPlacement = "bottom-start" | "bottom-end" | "top-start" | "top-end";
+/**
+ * Preset for quick date range selection
+ */
+export interface DateRangePreset {
+    label: string;
+    getValue: () => DateRange;
+}
+/**
+ * Main DateRangePicker component props
+ * Always operates on DateRange — no single date mode
+ */
+export interface DateRangePickerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue" | "onFocus" | "onBlur"> {
+    /** Unique identifier */
+    id?: string;
+    /** Form field name */
+    name?: string;
+    /** Size variant */
+    size?: DateRangePickerSize;
+    /** State variant */
+    state?: DateRangePickerState;
+    /** The selected date range (controlled mode) */
+    value?: DateRange;
+    /** Default selected date range (uncontrolled mode) */
+    defaultValue?: DateRange;
+    /** Placeholder text when no range selected */
+    placeholder?: string;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Label for the field */
+    label?: string;
+    /** Helper text below the field */
+    helperText?: string;
+    /** Callback fired when a range is applied */
+    onChange?: (range: DateRange | null) => void;
+    /** Array of preset date ranges */
+    presets?: DateRangePreset[];
+    /** Whether to show presets sidebar (default: true) */
+    showPresets?: boolean;
+    /** Focus event handler */
+    onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    /** Blur event handler */
+    onBlur?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    /** Minimum selectable date */
+    minDate?: Date;
+    /** Maximum selectable date */
+    maxDate?: Date;
+    /** Function to determine if a specific date should be disabled */
+    isDateDisabled?: (date: Date) => boolean;
+    /** Whether to highlight today's date (default: true) */
+    showToday?: boolean;
+    /** Custom weekday labels */
+    weekdays?: string[];
+    /** Custom month names */
+    months?: string[];
+    /** Format for displaying selected date (Intl API) */
+    dateFormat?: Intl.DateTimeFormatOptions;
+    /** Custom format string (e.g., 'DD MMM YYYY') - takes precedence over dateFormat */
+    formatString?: string;
+    /** Year range for the year dropdown */
+    yearRange?: {
+        start: number;
+        end: number;
+    };
+    /** Additional class name for trigger button */
+    className?: string;
+    /** Additional class name for wrapper */
+    wrapperClassName?: string;
+    /** Whether to use portal rendering (default: true) */
+    portal?: boolean;
+    /** Popover placement */
+    placement?: DateRangePickerPlacement;
+    /** Offset from trigger element */
+    offset?: number;
+}
+/**
+ * DateRangePicker trigger button props
+ */
+export interface DateRangePickerTriggerProps {
+    id?: string;
+    disabled?: boolean;
+    isOpen?: boolean;
+    state?: DateRangePickerState;
+    size?: DateRangePickerSize;
+    className?: string;
+    onClick?: () => void;
+    onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    children?: React.ReactNode;
+}
+/**
+ * DateRangePicker body props
+ */
+export interface DateRangePickerBodyProps {
+    isOpen?: boolean;
+    className?: string;
+    onClose?: () => void;
+    portal?: boolean;
+    placement?: DateRangePickerPlacement;
+    offset?: number;
+    presets?: DateRangePreset[];
+    showPresets?: boolean;
+}
+/**
+ * DateRangePicker presets props
+ */
+export interface DateRangePickerPresetsProps {
+    presets: DateRangePreset[];
+    className?: string;
+    tempRange?: DateRange;
+    setTempRange?: React.Dispatch<React.SetStateAction<DateRange | undefined>>;
+    onPresetSelect?: (range: DateRange) => void;
+}
+/**
+ * Theme interface for DateRangePicker (flat structure following library pattern)
+ */
+export interface DateRangePickerTheme {
+    containerStyle: string;
+    baseStyle: string;
+    triggerButtonStyle: string;
+    placeholderTextStyle: string;
+    valueTextStyle: string;
+    triggerSizes: Record<DateRangePickerSize, string>;
+    triggerStates: Record<DateRangePickerState, string>;
+    triggerHoverStates: Record<DateRangePickerState, string>;
+    triggerFocusStates: Record<DateRangePickerState, string>;
+    iconEndStyle: string;
+    iconEndPadding: string;
+    bodyStyle: string;
+    presetsContainerStyle: string;
+    presetButtonStyle: string;
+    presetCheckmarkStyle: string;
+    mobilePresetsContainerStyle: string;
+    mobilePresetButtonStyle: string;
+    mobileRangeDisplayStyle: string;
+    helperTextStyle: string;
+    helperTextStates: Record<DateRangePickerState, string>;
+}

package/dist/components/forms/DateRangePicker/DateRangePickerBody.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { DateRangePickerBodyProps } from "./DateRangePicker.types";
+/**
+ * DateRangePicker Body Component — dual calendars + presets sidebar + footer
+ */
+export declare const DateRangePickerBody: React.FC<DateRangePickerBodyProps>;

package/dist/components/forms/DateRangePicker/DateRangePickerBody.js

@@ -0,0 +1,208 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import React__default, { useContext, useState, useEffect, useCallback, useMemo } from 'react';
+import { AnimatePresence, motion } from 'motion/react';
+import { createPortal } from 'react-dom';
+import { Calendar } from '../../core/Calendar/Calendar.js';
+import '../../core/Calendar/CalendarMini/CalendarMini.js';
+import { Button } from '../../core/Button/Button.js';
+import { cn } from '../../../utils/cn.js';
+import { DateRangePickerContext } from './DateRangePicker.js';
+import { DateRangePickerPresets } from './DateRangePickerPresets.js';
+import { useSelectPortal } from '../../../hooks/useSelectPortal.js';
+import { formatDateCustom } from '../../../utils/dateUtils.js';
+import { createDropdownAnimations } from '../DatePicker/DatePicker.animations.js';
+import { useIsClient } from '../../../hooks/useIsClient.js';
+import { useMediaQuery } from '../../../hooks/useMediaQuery.js';
+
+/**
+ * Hook to detect dark mode state from document
+ */
+const useDarkMode = () => {
+    const [isDark, setIsDark] = useState(false);
+    useEffect(() => {
+        if (typeof document === "undefined")
+            return;
+        const checkDarkMode = () => {
+            const hasDarkClass = document.documentElement.classList.contains("dark") ||
+                document.body.classList.contains("dark") ||
+                document.querySelector(".dark") !== null;
+            setIsDark(hasDarkClass);
+        };
+        checkDarkMode();
+        const observer = new MutationObserver(checkDarkMode);
+        observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ["class"],
+        });
+        observer.observe(document.body, {
+            attributes: true,
+            attributeFilter: ["class"],
+        });
+        return () => observer.disconnect();
+    }, []);
+    return isDark;
+};
+/**
+ * DateRangePicker Body Component — dual calendars + presets sidebar + footer
+ */
+const DateRangePickerBody = ({ isOpen, className, onClose, portal = true, placement = "bottom-start", offset = 4, presets, showPresets = true, }) => {
+    const context = useContext(DateRangePickerContext);
+    if (!context) {
+        throw new Error("DateRangePickerBody must be used within a DateRangePicker");
+    }
+    const { theme, triggerRef, contentRef, selectedRange, minDate, maxDate, isDateDisabled, showToday, weekdays, months, handleRangeSelect, yearRange, } = context;
+    const hasPresets = showPresets && presets && presets.length > 0;
+    const isDarkMode = useDarkMode();
+    const isClient = useIsClient();
+    const isMobile = useMediaQuery("(max-width: 639px)");
+    // Temp range state — not committed until Apply is clicked
+    const [tempRange, setTempRange] = useState(selectedRange);
+    // Sync temp range when panel opens
+    useEffect(() => {
+        if (isOpen) {
+            setTempRange(selectedRange);
+        }
+    }, [isOpen, selectedRange]);
+    // Handle preset selection — update calendar view to show the range
+    const handlePresetSelect = useCallback((range) => {
+        if (range.start) {
+            setLeftCalendarDate(new Date(range.start.getFullYear(), range.start.getMonth(), 1));
+        }
+    }, []);
+    // Dual calendar state
+    const getInitialLeftDate = () => {
+        if (tempRange === null || tempRange === void 0 ? void 0 : tempRange.start) {
+            return new Date(tempRange.start.getFullYear(), tempRange.start.getMonth(), 1);
+        }
+        if (selectedRange === null || selectedRange === void 0 ? void 0 : selectedRange.start) {
+            return new Date(selectedRange.start.getFullYear(), selectedRange.start.getMonth(), 1);
+        }
+        return new Date();
+    };
+    const [leftCalendarDate, setLeftCalendarDate] = useState(getInitialLeftDate);
+    const rightCalendarDate = useMemo(() => {
+        const nextMonth = new Date(leftCalendarDate);
+        nextMonth.setMonth(nextMonth.getMonth() + 1);
+        return nextMonth;
+    }, [leftCalendarDate]);
+    const handleNavigatePrev = useCallback(() => {
+        setLeftCalendarDate((prev) => {
+            const newDate = new Date(prev);
+            newDate.setMonth(newDate.getMonth() - 1);
+            return newDate;
+        });
+    }, []);
+    const handleNavigateNext = useCallback(() => {
+        setLeftCalendarDate((prev) => {
+            const newDate = new Date(prev);
+            newDate.setMonth(newDate.getMonth() + 1);
+            return newDate;
+        });
+    }, []);
+    // Footer handlers
+    const handleApply = useCallback(() => {
+        if (tempRange) {
+            handleRangeSelect(tempRange);
+        }
+        onClose === null || onClose === void 0 ? void 0 : onClose();
+    }, [tempRange, handleRangeSelect, onClose]);
+    const handleCancel = useCallback(() => {
+        setTempRange(selectedRange);
+        onClose === null || onClose === void 0 ? void 0 : onClose();
+    }, [selectedRange, onClose]);
+    // Format range for footer display
+    const formatRangeDisplay = (range) => {
+        if (!(range === null || range === void 0 ? void 0 : range.start) && !(range === null || range === void 0 ? void 0 : range.end))
+            return "Select start and end dates";
+        if (!range.end)
+            return `${formatDateCustom(range.start, "DD/MM/YYYY")} - ...`;
+        return `${formatDateCustom(range.start, "DD/MM/YYYY")} - ${formatDateCustom(range.end, "DD/MM/YYYY")}`;
+    };
+    // Portal positioning
+    const { position, cssVariables, contentRef: portalContentRef, isFlipped, isReady, } = useSelectPortal({
+        triggerRef,
+        isOpen: isOpen || false,
+        placement,
+        offset,
+        autoWidth: true,
+    });
+    const animations = createDropdownAnimations(isFlipped);
+    // Combine refs
+    const combinedRef = React__default.useCallback((el) => {
+        if (contentRef &&
+            typeof contentRef === "object" &&
+            "current" in contentRef) {
+            contentRef.current =
+                el;
+        }
+        if (portalContentRef &&
+            typeof portalContentRef === "object" &&
+            "current" in portalContentRef) {
+            portalContentRef.current = el;
+        }
+    }, [contentRef, portalContentRef]);
+    // Click outside to close
+    useEffect(() => {
+        if (!isOpen)
+            return;
+        const handleClickOutside = (event) => {
+            var _a;
+            const target = event.target;
+            if ((_a = target.closest) === null || _a === void 0 ? void 0 : _a.call(target, '[role="listbox"]')) {
+                return;
+            }
+            const currentContentRef = portal
+                ? portalContentRef.current
+                : contentRef.current;
+            if (currentContentRef &&
+                !currentContentRef.contains(target) &&
+                triggerRef.current &&
+                !triggerRef.current.contains(target)) {
+                onClose === null || onClose === void 0 ? void 0 : onClose();
+            }
+        };
+        document.addEventListener("mousedown", handleClickOutside);
+        return () => {
+            document.removeEventListener("mousedown", handleClickOutside);
+        };
+    }, [isOpen, onClose, triggerRef, contentRef, portalContentRef, portal]);
+    // Escape key
+    useEffect(() => {
+        if (!isOpen)
+            return;
+        const handleKeyDown = (event) => {
+            if (event.key === "Escape") {
+                onClose === null || onClose === void 0 ? void 0 : onClose();
+            }
+        };
+        document.addEventListener("keydown", handleKeyDown);
+        return () => {
+            document.removeEventListener("keydown", handleKeyDown);
+        };
+    }, [isOpen, onClose]);
+    const contentElement = (jsx(AnimatePresence, { mode: "wait", children: isOpen && (jsxs(motion.div, { ref: combinedRef, className: cn(theme.bodyStyle, className), style: {
+                ...cssVariables,
+                ...(portal
+                    ? {
+                        top: `${position.top}px`,
+                        left: `${position.left}px`,
+                        minWidth: `${position.width}px`,
+                    }
+                    : {}),
+            }, variants: animations, initial: "initial", animate: isReady ? "visible" : "initial", exit: "exit", children: [hasPresets && presets && (jsx(DateRangePickerPresets, { presets: presets, tempRange: tempRange, setTempRange: setTempRange, onPresetSelect: handlePresetSelect })), jsxs("div", { className: "flex flex-col flex-1", children: [jsxs("div", { className: "flex flex-col sm:flex-row justify-between items-center sm:items-start gap-2 sm:gap-6 p-3 sm:p-4", children: [jsx("div", { className: "flex-1 min-w-fit", children: jsx(Calendar, { mode: "range", value: tempRange, onChange: (value) => {
+                                            setTempRange(value);
+                                        }, viewDate: leftCalendarDate, onViewDateChange: setLeftCalendarDate, onNavigatePrev: handleNavigatePrev, onNavigateNext: isMobile ? handleNavigateNext : null, minDate: minDate, maxDate: maxDate, isDateDisabled: isDateDisabled, showToday: showToday, selectTodayByDefault: false, weekdays: weekdays, months: months, yearRange: yearRange, showOtherMonthDays: false, headerMode: "static", size: "md" }) }), jsx("div", { className: "hidden sm:block flex-1 min-w-fit", children: jsx(Calendar, { mode: "range", value: tempRange, onChange: (value) => {
+                                            setTempRange(value);
+                                        }, viewDate: rightCalendarDate, onViewDateChange: (newDate) => {
+                                            const adjustedLeft = new Date(newDate);
+                                            adjustedLeft.setMonth(adjustedLeft.getMonth() - 1);
+                                            setLeftCalendarDate(adjustedLeft);
+                                        }, onNavigatePrev: null, onNavigateNext: handleNavigateNext, minDate: minDate, maxDate: maxDate, isDateDisabled: isDateDisabled, showToday: showToday, selectTodayByDefault: false, weekdays: weekdays, months: months, yearRange: yearRange, showOtherMonthDays: false, headerMode: "static", size: "md" }) })] }), jsxs("div", { className: "flex flex-col sm:flex-row sm:items-center sm:justify-between gap-2 px-3 sm:px-4 py-3 border-t border-[var(--color-border)]", children: [jsx("div", { className: "text-sm text-center sm:text-left text-[var(--color-text-muted)]", children: formatRangeDisplay(tempRange) }), jsxs("div", { className: "flex w-full sm:w-auto items-center gap-2", children: [jsx(Button, { variant: "outline", color: "neutral", size: "sm", className: "flex-1 sm:flex-initial", onClick: handleCancel, children: "Cancel" }), jsx(Button, { variant: "filled", size: "sm", className: "flex-1 sm:flex-initial", onClick: handleApply, disabled: !(tempRange === null || tempRange === void 0 ? void 0 : tempRange.start) || !(tempRange === null || tempRange === void 0 ? void 0 : tempRange.end), children: "Apply" })] })] })] })] })) }));
+    if (portal && isClient) {
+        return createPortal(jsx("div", { className: isDarkMode ? "dark" : undefined, children: contentElement }), document.body);
+    }
+    return contentElement;
+};
+DateRangePickerBody.displayName = "DateRangePicker.Body";
+
+export { DateRangePickerBody };

package/dist/components/forms/DateRangePicker/DateRangePickerPresets.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { DateRangePickerPresetsProps } from "./DateRangePicker.types";
+/**
+ * DateRangePicker Presets Component — shows preset buttons with checkmarks
+ */
+export declare const DateRangePickerPresets: React.FC<DateRangePickerPresetsProps>;

package/dist/components/forms/DateRangePicker/DateRangePickerPresets.js

@@ -0,0 +1,41 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useContext } from 'react';
+import { CheckIcon } from '@heroicons/react/24/outline';
+import { DateRangePickerContext } from './DateRangePicker.js';
+import { cn } from '../../../utils/cn.js';
+
+/**
+ * DateRangePicker Presets Component — shows preset buttons with checkmarks
+ */
+const DateRangePickerPresets = ({ presets, className, tempRange, setTempRange, onPresetSelect, }) => {
+    const context = useContext(DateRangePickerContext);
+    if (!context) {
+        throw new Error("DateRangePickerPresets must be used within a DateRangePicker");
+    }
+    const { theme } = context;
+    const isSameDate = (d1, d2) => {
+        if (!d1 || !d2)
+            return d1 === d2;
+        return (d1.getFullYear() === d2.getFullYear() &&
+            d1.getMonth() === d2.getMonth() &&
+            d1.getDate() === d2.getDate());
+    };
+    const isPresetActive = (preset) => {
+        if (!tempRange)
+            return false;
+        const presetRange = preset.getValue();
+        return (isSameDate(tempRange.start, presetRange.start) &&
+            isSameDate(tempRange.end, presetRange.end));
+    };
+    const handlePresetClick = (preset) => {
+        const range = preset.getValue();
+        setTempRange === null || setTempRange === void 0 ? void 0 : setTempRange(range);
+        onPresetSelect === null || onPresetSelect === void 0 ? void 0 : onPresetSelect(range);
+    };
+    return (jsx("div", { className: cn(theme.presetsContainerStyle, className), children: presets.map((preset, index) => {
+            const active = isPresetActive(preset);
+            return (jsxs("button", { type: "button", onClick: () => handlePresetClick(preset), className: theme.presetButtonStyle, "data-active": active, children: [jsx("span", { children: preset.label }), active && jsx(CheckIcon, { className: theme.presetCheckmarkStyle })] }, index));
+        }) }));
+};
+
+export { DateRangePickerPresets };

package/dist/components/forms/DateRangePicker/DateRangePickerTrigger.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { DateRangePickerTriggerProps } from "./DateRangePicker.types";
+/**
+ * DateRangePicker Trigger Component — styled like form input
+ */
+export declare const DateRangePickerTrigger: React.FC<DateRangePickerTriggerProps>;

package/dist/components/forms/DateRangePicker/DateRangePickerTrigger.js

@@ -0,0 +1,32 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useContext } from 'react';
+import { CalendarIcon } from '@heroicons/react/24/outline';
+import { cn } from '../../../utils/cn.js';
+import { DateRangePickerContext } from './DateRangePicker.js';
+
+/**
+ * DateRangePicker Trigger Component — styled like form input
+ */
+const DateRangePickerTrigger = ({ id, disabled, isOpen, state = "default", size = "md", className, onClick, onFocus, onBlur, children, }) => {
+    var _a, _b, _c, _d;
+    const context = useContext(DateRangePickerContext);
+    if (!context) {
+        throw new Error("DateRangePickerTrigger must be used within a DateRangePicker");
+    }
+    const { theme, triggerRef } = context;
+    const baseStyle = theme.baseStyle || "";
+    const sizeStyle = ((_a = theme.triggerSizes) === null || _a === void 0 ? void 0 : _a[size]) || "";
+    const stateStyle = ((_b = theme.triggerStates) === null || _b === void 0 ? void 0 : _b[state]) || "";
+    const hoverStateStyle = ((_c = theme.triggerHoverStates) === null || _c === void 0 ? void 0 : _c[state]) || "";
+    const focusStateStyle = ((_d = theme.triggerFocusStates) === null || _d === void 0 ? void 0 : _d[state]) || "";
+    const iconEndStyle = theme.iconEndStyle || "";
+    const iconEndPadding = theme.iconEndPadding || "";
+    const triggerButtonStyle = theme.triggerButtonStyle || "";
+    const activeFocusState = isOpen
+        ? focusStateStyle ||
+            "outline-2 outline-primary-600 -outline-offset-1 ring-4 ring-[var(--color-primary)]/10"
+        : "";
+    return (jsx("div", { className: "relative w-full", children: jsxs("button", { ref: triggerRef, id: id, type: "button", className: cn(baseStyle, sizeStyle, stateStyle, hoverStateStyle, activeFocusState, iconEndPadding, triggerButtonStyle, "text-left", className), onClick: onClick, onFocus: onFocus, onBlur: onBlur, disabled: disabled, "aria-expanded": isOpen, "aria-haspopup": "dialog", "aria-label": "Open date range picker", children: [children, jsx("span", { className: iconEndStyle, children: jsx(CalendarIcon, { className: "h-4 w-4" }) })] }) }));
+};
+
+export { DateRangePickerTrigger };

package/dist/components/forms/DateRangePicker/dateRangePresets.d.ts

@@ -0,0 +1,5 @@
+import type { DateRangePreset } from "./DateRangePicker.types";
+/**
+ * Default date range presets matching the reference design
+ */
+export declare const DEFAULT_DATE_RANGE_PRESETS: DateRangePreset[];