@tribepad/themis 1.0.0 → 1.0.1

package/dist/elements/DatePicker/index.js

@@ -1,123 +1,905 @@
+"use client";
 'use strict';
 
-var chunkZP2KV6EX_js = require('../../chunk-ZP2KV6EX.js');
-require('../../chunk-CJIW5TKI.js');
-require('../../chunk-B5Q4UPL6.js');
-require('../../chunk-VIREG536.js');
+var react = require('react');
+var reactAriaComponents = require('react-aria-components');
+var lucideReact = require('lucide-react');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var classVarianceAuthority = require('class-variance-authority');
+var jsxRuntime = require('react/jsx-runtime');
+var zod = require('zod');
+var date = require('@internationalized/date');
 
+// src/elements/DatePicker/DatePicker.tsx
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
 
+// src/styles/shared-variants.ts
+var FOCUS_WITHIN_RING = [
+  "focus-within:outline-none",
+  "focus-within:ring-2",
+  "focus-within:ring-[var(--ring)]",
+  "focus-within:ring-offset-2"
+];
+var FOCUS_RING = [
+  "focus:outline-none",
+  "focus:ring-2",
+  "focus:ring-[var(--ring)]"
+];
+var FOCUS_HIGHLIGHT = [
+  "focus:outline-none",
+  "focus:bg-[var(--accent)]",
+  "focus:text-[var(--accent-foreground)]"
+];
+var DISABLED_STANDARD = [
+  "disabled:pointer-events-none",
+  "disabled:opacity-50"
+];
+var DISABLED_DATA_ATTR = [
+  "data-[disabled]:pointer-events-none",
+  "data-[disabled]:opacity-50",
+  "data-[disabled]:cursor-not-allowed"
+];
+var TEXT_SIZE_SMALL_SCALE = {
+  sm: "text-xs",
+  default: "text-sm",
+  lg: "text-base"
+};
+var TEXT_SIZE_MEDIUM_SCALE = {
+  sm: "text-sm",
+  default: "text-base",
+  lg: "text-lg"
+};
+var FIELD_HEIGHTS = {
+  sm: "h-9",
+  // 36px
+  default: "h-11",
+  // 44px
+  lg: "h-14"
+  // 56px
+};
+var ERROR_MESSAGE_BASE = [
+  "flex",
+  "items-center",
+  "gap-1.5",
+  "text-[var(--destructive)]"
+];
+var DESCRIPTION_BASE = [
+  "text-[var(--menu-muted)]"
+];
+var LABEL_BASE = [
+  "font-medium",
+  "text-[var(--content-foreground)]"
+];
+var POPOVER_ANIMATION_IN = [
+  "data-[entering]:animate-in",
+  "data-[entering]:fade-in-0",
+  "data-[entering]:zoom-in-95"
+];
+var POPOVER_ANIMATION_OUT = [
+  "data-[exiting]:animate-out",
+  "data-[exiting]:fade-out-0",
+  "data-[exiting]:zoom-out-95"
+];
+var REDUCED_MOTION = [
+  "motion-reduce:transition-none",
+  "motion-reduce:animate-none"
+];
+var TRANSITION_FAST = [
+  "transition-colors",
+  "duration-150"
+];
+var HOVER_ACCENT = [
+  "hover:bg-[var(--accent)]",
+  "hover:text-[var(--accent-foreground)]"
+];
+function combineStyles(...styles) {
+  return styles.flatMap((s) => Array.isArray(s) ? [...s] : [s]);
+}
 
-Object.defineProperty(exports, "Calendar", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.Calendar; }
-});
-Object.defineProperty(exports, "CalendarPropsSchema", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.CalendarPropsSchema; }
-});
-Object.defineProperty(exports, "DateField", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.DateField; }
+// src/elements/DatePicker/DatePicker.variants.ts
+var dateFieldVariants = classVarianceAuthority.cva(
+  combineStyles(
+    "flex items-center rounded-md border",
+    "bg-[var(--content-background)] text-[var(--content-foreground)]",
+    "transition-colors duration-200",
+    FOCUS_WITHIN_RING,
+    DISABLED_DATA_ATTR
+  ),
+  {
+    variants: {
+      size: {
+        sm: `${FIELD_HEIGHTS.sm} px-3 text-sm gap-0.5`,
+        default: `${FIELD_HEIGHTS.default} px-4 text-base gap-1`,
+        lg: `${FIELD_HEIGHTS.lg} px-5 text-lg gap-1.5`
+      },
+      isInvalid: {
+        true: "border-[var(--destructive)] focus-within:ring-[var(--destructive)]",
+        false: "border-[var(--input)] hover:border-[var(--input)]/80"
+      }
+    },
+    defaultVariants: {
+      size: "default",
+      isInvalid: false
+    }
+  }
+);
+var dateSegmentVariants = classVarianceAuthority.cva(
+  combineStyles(
+    "tabular-nums rounded px-0.5",
+    FOCUS_HIGHLIGHT,
+    "data-[placeholder]:text-[var(--menu-muted)]",
+    "data-[type=literal]:text-[var(--menu-muted)]"
+  ),
+  {
+    variants: {
+      size: TEXT_SIZE_MEDIUM_SCALE
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var calendarCellVariants = classVarianceAuthority.cva(
+  combineStyles(
+    "flex items-center justify-center rounded-md cursor-pointer",
+    TRANSITION_FAST,
+    HOVER_ACCENT,
+    FOCUS_RING,
+    // Selected state
+    "data-[selected]:bg-[var(--primary)] data-[selected]:text-[var(--primary-foreground)]",
+    "data-[selected]:hover:bg-[var(--primary)]/90 data-[selected]:font-semibold",
+    // Today indicator
+    "data-[today]:border data-[today]:border-[var(--primary)]",
+    // Range selection
+    "data-[selection-start]:rounded-l-md data-[selection-start]:rounded-r-none",
+    "data-[selection-end]:rounded-r-md data-[selection-end]:rounded-l-none",
+    "data-[selected]:data-[selection-start]:rounded-l-md",
+    "data-[selected]:data-[selection-end]:rounded-r-md",
+    // Unavailable/outside/disabled states
+    "data-[unavailable]:text-[var(--menu-muted)] data-[unavailable]:pointer-events-none data-[unavailable]:opacity-50 data-[unavailable]:line-through",
+    "data-[outside-month]:text-[var(--menu-muted)] data-[outside-month]:opacity-50",
+    "data-[disabled]:text-[var(--menu-muted)] data-[disabled]:pointer-events-none data-[disabled]:opacity-50"
+  ),
+  {
+    variants: {
+      size: {
+        sm: "h-9 w-9 text-sm",
+        default: "h-11 w-11 text-base",
+        lg: "h-14 w-14 text-lg"
+      }
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var calendarHeaderVariants = classVarianceAuthority.cva(
+  "flex items-center justify-between px-1 pb-4",
+  {
+    variants: {
+      size: TEXT_SIZE_MEDIUM_SCALE
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var calendarNavButtonVariants = classVarianceAuthority.cva(
+  combineStyles(
+    "inline-flex items-center justify-center rounded-md text-[var(--menu-muted)]",
+    TRANSITION_FAST,
+    HOVER_ACCENT,
+    FOCUS_RING,
+    DISABLED_STANDARD
+  ),
+  {
+    variants: {
+      size: {
+        sm: "h-7 w-7",
+        default: "h-9 w-9",
+        lg: "h-11 w-11"
+      }
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var calendarGridVariants = classVarianceAuthority.cva(
+  "w-full border-collapse",
+  {
+    variants: {
+      size: TEXT_SIZE_MEDIUM_SCALE
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var calendarGridHeaderCellVariants = classVarianceAuthority.cva(
+  "text-center font-medium text-[var(--menu-muted)] pb-2",
+  {
+    variants: {
+      size: {
+        sm: "text-xs w-9",
+        default: "text-sm w-11",
+        lg: "text-base w-14"
+      }
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var datePickerPopoverVariants = classVarianceAuthority.cva(
+  combineStyles(
+    "z-50 rounded-md border p-3 shadow-md outline-none",
+    "bg-[var(--menu-background)] text-[var(--menu-foreground)]",
+    POPOVER_ANIMATION_IN,
+    POPOVER_ANIMATION_OUT,
+    REDUCED_MOTION
+  ),
+  {
+    variants: {
+      size: {
+        sm: "w-[260px]",
+        default: "w-[320px]",
+        lg: "w-[380px]"
+      }
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var datePickerTriggerVariants = classVarianceAuthority.cva(
+  combineStyles(
+    "inline-flex items-center justify-center rounded-md text-[var(--menu-muted)]",
+    TRANSITION_FAST,
+    HOVER_ACCENT,
+    FOCUS_RING,
+    DISABLED_DATA_ATTR
+  ),
+  {
+    variants: {
+      size: {
+        sm: "h-7 w-7",
+        default: "h-9 w-9",
+        lg: "h-11 w-11"
+      }
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var datePickerDescriptionVariants = classVarianceAuthority.cva(
+  combineStyles(DESCRIPTION_BASE, "mt-1"),
+  {
+    variants: {
+      size: TEXT_SIZE_SMALL_SCALE
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var datePickerErrorVariants = classVarianceAuthority.cva(
+  combineStyles(ERROR_MESSAGE_BASE, "mt-1"),
+  {
+    variants: {
+      size: TEXT_SIZE_SMALL_SCALE
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var datePickerLabelVariants = classVarianceAuthority.cva(
+  combineStyles(
+    LABEL_BASE,
+    "block mb-1.5",
+    'data-[required]:after:content-["*"] data-[required]:after:ml-0.5 data-[required]:after:text-[var(--destructive)]'
+  ),
+  {
+    variants: {
+      size: {
+        sm: "text-sm",
+        default: "text-sm",
+        lg: "text-base"
+      }
+    },
+    defaultVariants: {
+      size: "default"
+    }
+  }
+);
+var DatePickerContext = react.createContext({
+  size: "default"
 });
-Object.defineProperty(exports, "DateFieldPropsSchema", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.DateFieldPropsSchema; }
+var DatePicker = react.forwardRef(
+  ({
+    label,
+    description,
+    errorMessage,
+    size = "default",
+    className,
+    placement = "bottom",
+    ...props
+  }, ref) => {
+    const contextValue = react.useMemo(
+      () => ({
+        size,
+        isInvalid: props.isInvalid,
+        isDisabled: props.isDisabled
+      }),
+      [size, props.isInvalid, props.isDisabled]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(DatePickerContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(
+      reactAriaComponents.DatePicker,
+      {
+        ref,
+        className: cn("group flex flex-col gap-1", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Label,
+            {
+              className: cn(datePickerLabelVariants({ size })),
+              "data-required": props.isRequired || void 0,
+              children: label
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            reactAriaComponents.Group,
+            {
+              className: cn(
+                dateFieldVariants({
+                  size,
+                  isInvalid: props.isInvalid
+                })
+              ),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.DateInput, { className: "flex flex-1 items-center", children: (segment) => /* @__PURE__ */ jsxRuntime.jsx(
+                  reactAriaComponents.DateSegment,
+                  {
+                    segment,
+                    className: cn(dateSegmentVariants({ size }))
+                  }
+                ) }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  reactAriaComponents.Button,
+                  {
+                    className: cn(datePickerTriggerVariants({ size })),
+                    "aria-label": "Open calendar",
+                    children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Calendar, { className: "h-4 w-4" })
+                  }
+                )
+              ]
+            }
+          ),
+          description && /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Text,
+            {
+              slot: "description",
+              className: cn(datePickerDescriptionVariants({ size })),
+              children: description
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.FieldError, { className: cn(datePickerErrorVariants({ size })), children: errorMessage }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Popover,
+            {
+              placement,
+              className: cn(datePickerPopoverVariants({ size })),
+              children: /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Dialog, { className: "outline-none", children: /* @__PURE__ */ jsxRuntime.jsxs(reactAriaComponents.Calendar, { className: "w-full", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn(calendarHeaderVariants({ size })), children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.Button,
+                    {
+                      slot: "previous",
+                      className: cn(calendarNavButtonVariants({ size })),
+                      "aria-label": "Previous month",
+                      children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronLeft, { className: "h-4 w-4" })
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Heading, { className: "flex-1 text-center font-semibold" }),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.Button,
+                    {
+                      slot: "next",
+                      className: cn(calendarNavButtonVariants({ size })),
+                      "aria-label": "Next month",
+                      children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, { className: "h-4 w-4" })
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsxs(reactAriaComponents.CalendarGrid, { className: cn(calendarGridVariants({ size })), children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.CalendarGridHeader, { children: (day) => /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.CalendarHeaderCell,
+                    {
+                      className: cn(calendarGridHeaderCellVariants({ size })),
+                      children: day
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.CalendarGridBody, { children: (date) => /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.CalendarCell,
+                    {
+                      date,
+                      className: cn(calendarCellVariants({ size }))
+                    }
+                  ) })
+                ] })
+              ] }) })
+            }
+          )
+        ]
+      }
+    ) });
+  }
+);
+DatePicker.displayName = "DatePicker";
+var DateRangePicker = react.forwardRef(
+  ({
+    label,
+    description,
+    errorMessage,
+    size = "default",
+    className,
+    placement = "bottom",
+    startName,
+    endName,
+    ...props
+  }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      reactAriaComponents.DateRangePicker,
+      {
+        ref,
+        className: cn("group flex flex-col gap-1", className),
+        startName,
+        endName,
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Label,
+            {
+              className: cn(datePickerLabelVariants({ size })),
+              "data-required": props.isRequired || void 0,
+              children: label
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            reactAriaComponents.Group,
+            {
+              className: cn(
+                dateFieldVariants({
+                  size,
+                  isInvalid: props.isInvalid
+                })
+              ),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.DateInput, { slot: "start", className: "flex items-center", children: (segment) => /* @__PURE__ */ jsxRuntime.jsx(
+                  reactAriaComponents.DateSegment,
+                  {
+                    segment,
+                    className: cn(dateSegmentVariants({ size }))
+                  }
+                ) }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "span",
+                  {
+                    "aria-hidden": "true",
+                    className: "px-2 text-[var(--menu-muted)]",
+                    children: "\u2013"
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.DateInput, { slot: "end", className: "flex items-center", children: (segment) => /* @__PURE__ */ jsxRuntime.jsx(
+                  reactAriaComponents.DateSegment,
+                  {
+                    segment,
+                    className: cn(dateSegmentVariants({ size }))
+                  }
+                ) }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  reactAriaComponents.Button,
+                  {
+                    className: cn(datePickerTriggerVariants({ size })),
+                    "aria-label": "Open calendar",
+                    children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Calendar, { className: "h-4 w-4" })
+                  }
+                )
+              ]
+            }
+          ),
+          description && /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Text,
+            {
+              slot: "description",
+              className: cn(datePickerDescriptionVariants({ size })),
+              children: description
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.FieldError, { className: cn(datePickerErrorVariants({ size })), children: errorMessage }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Popover,
+            {
+              placement,
+              className: cn(datePickerPopoverVariants({ size })),
+              children: /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Dialog, { className: "outline-none", children: /* @__PURE__ */ jsxRuntime.jsxs(reactAriaComponents.RangeCalendar, { className: "w-full", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn(calendarHeaderVariants({ size })), children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.Button,
+                    {
+                      slot: "previous",
+                      className: cn(calendarNavButtonVariants({ size })),
+                      "aria-label": "Previous month",
+                      children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronLeft, { className: "h-4 w-4" })
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Heading, { className: "flex-1 text-center font-semibold" }),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.Button,
+                    {
+                      slot: "next",
+                      className: cn(calendarNavButtonVariants({ size })),
+                      "aria-label": "Next month",
+                      children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, { className: "h-4 w-4" })
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsxs(reactAriaComponents.CalendarGrid, { className: cn(calendarGridVariants({ size })), children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.CalendarGridHeader, { children: (day) => /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.CalendarHeaderCell,
+                    {
+                      className: cn(calendarGridHeaderCellVariants({ size })),
+                      children: day
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.CalendarGridBody, { children: (date) => /* @__PURE__ */ jsxRuntime.jsx(
+                    reactAriaComponents.CalendarCell,
+                    {
+                      date,
+                      className: cn(calendarCellVariants({ size }))
+                    }
+                  ) })
+                ] })
+              ] }) })
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+DateRangePicker.displayName = "DateRangePicker";
+var DateField = react.forwardRef(
+  ({
+    label,
+    description,
+    errorMessage,
+    size = "default",
+    className,
+    ...props
+  }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      reactAriaComponents.DateField,
+      {
+        ref,
+        className: cn("group flex flex-col gap-1", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Label,
+            {
+              className: cn(datePickerLabelVariants({ size })),
+              "data-required": props.isRequired || void 0,
+              children: label
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.DateInput,
+            {
+              className: cn(
+                dateFieldVariants({
+                  size,
+                  isInvalid: props.isInvalid
+                }),
+                "w-fit"
+              ),
+              children: (segment) => /* @__PURE__ */ jsxRuntime.jsx(
+                reactAriaComponents.DateSegment,
+                {
+                  segment,
+                  className: cn(dateSegmentVariants({ size }))
+                }
+              )
+            }
+          ),
+          description && /* @__PURE__ */ jsxRuntime.jsx(
+            reactAriaComponents.Text,
+            {
+              slot: "description",
+              className: cn(datePickerDescriptionVariants({ size })),
+              children: description
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.FieldError, { className: cn(datePickerErrorVariants({ size })), children: errorMessage })
+        ]
+      }
+    );
+  }
+);
+DateField.displayName = "DateField";
+var Calendar = react.forwardRef(
+  ({ size = "default", className, ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      reactAriaComponents.Calendar,
+      {
+        ref,
+        className: cn("w-fit", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn(calendarHeaderVariants({ size })), children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              reactAriaComponents.Button,
+              {
+                slot: "previous",
+                className: cn(calendarNavButtonVariants({ size })),
+                "aria-label": "Previous month",
+                children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronLeft, { className: "h-4 w-4" })
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.Heading, { className: "flex-1 text-center font-semibold" }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              reactAriaComponents.Button,
+              {
+                slot: "next",
+                className: cn(calendarNavButtonVariants({ size })),
+                "aria-label": "Next month",
+                children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, { className: "h-4 w-4" })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(reactAriaComponents.CalendarGrid, { className: cn(calendarGridVariants({ size })), children: [
+            /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.CalendarGridHeader, { children: (day) => /* @__PURE__ */ jsxRuntime.jsx(
+              reactAriaComponents.CalendarHeaderCell,
+              {
+                className: cn(calendarGridHeaderCellVariants({ size })),
+                children: day
+              }
+            ) }),
+            /* @__PURE__ */ jsxRuntime.jsx(reactAriaComponents.CalendarGridBody, { children: (date) => /* @__PURE__ */ jsxRuntime.jsx(
+              reactAriaComponents.CalendarCell,
+              {
+                date,
+                className: cn(calendarCellVariants({ size }))
+              }
+            ) })
+          ] })
+        ]
+      }
+    );
+  }
+);
+Calendar.displayName = "Calendar";
+var DatePickerPropsSchema = zod.z.object({
+  // Value props
+  value: zod.z.custom().optional(),
+  defaultValue: zod.z.custom().optional(),
+  placeholderValue: zod.z.custom().optional(),
+  // Granularity props
+  granularity: zod.z.enum(["day", "hour", "minute", "second"]).default("day"),
+  hourCycle: zod.z.union([zod.z.literal(12), zod.z.literal(24)]).optional(),
+  hideTimeZone: zod.z.boolean().optional(),
+  shouldForceLeadingZeros: zod.z.boolean().optional(),
+  // Constraint props
+  minValue: zod.z.custom().optional(),
+  maxValue: zod.z.custom().optional(),
+  /** Callback to determine if a specific date is unavailable for selection */
+  isDateUnavailable: zod.z.function().optional(),
+  // State props
+  isOpen: zod.z.boolean().optional(),
+  defaultOpen: zod.z.boolean().optional(),
+  isDisabled: zod.z.boolean().optional(),
+  isReadOnly: zod.z.boolean().optional(),
+  isRequired: zod.z.boolean().optional(),
+  isInvalid: zod.z.boolean().optional(),
+  // Validation props
+  /** Custom validation function that returns an error message or null */
+  validate: zod.z.function().optional(),
+  validationBehavior: zod.z.enum(["native", "aria"]).default("native"),
+  // Display props
+  label: zod.z.string(),
+  description: zod.z.string().optional(),
+  /** Error message string or render function */
+  errorMessage: zod.z.union([zod.z.string(), zod.z.function()]).optional(),
+  // Calendar props
+  firstDayOfWeek: zod.z.enum(["sun", "mon", "tue", "wed", "thu", "fri", "sat"]).optional(),
+  pageBehavior: zod.z.enum(["single", "visible"]).optional(),
+  // Form props
+  name: zod.z.string().optional(),
+  // Popover props
+  placement: zod.z.enum(["bottom", "top", "left", "right"]).optional(),
+  visibleDuration: zod.z.object({ months: zod.z.number() }).optional(),
+  // Variant props
+  size: zod.z.enum(["sm", "default", "lg"]).default("default"),
+  // Event props
+  /** Called when the date value changes */
+  onChange: zod.z.function().optional(),
+  /** Called when the popover open state changes */
+  onOpenChange: zod.z.function().optional(),
+  /** Called when the field gains focus */
+  onFocus: zod.z.function().optional(),
+  /** Called when the field loses focus */
+  onBlur: zod.z.function().optional(),
+  /** Called when focus state changes */
+  onFocusChange: zod.z.function().optional(),
+  // Standard props
+  className: zod.z.string().optional(),
+  children: zod.z.any().optional()
 });
-Object.defineProperty(exports, "DatePicker", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.DatePicker; }
+var DateRangePickerPropsSchema = DatePickerPropsSchema.omit({
+  value: true,
+  defaultValue: true,
+  onChange: true
+}).extend({
+  // Range value props
+  value: zod.z.object({
+    start: zod.z.custom(),
+    end: zod.z.custom()
+  }).optional(),
+  defaultValue: zod.z.object({
+    start: zod.z.custom(),
+    end: zod.z.custom()
+  }).optional(),
+  // Form props for range
+  startName: zod.z.string().optional(),
+  endName: zod.z.string().optional(),
+  // Range event props
+  /** Called when the date range value changes */
+  onChange: zod.z.function().optional()
 });
-Object.defineProperty(exports, "DatePickerPropsSchema", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.DatePickerPropsSchema; }
+var DateFieldPropsSchema = zod.z.object({
+  // Value props
+  value: zod.z.custom().optional(),
+  defaultValue: zod.z.custom().optional(),
+  placeholderValue: zod.z.custom().optional(),
+  // Granularity props
+  granularity: zod.z.enum(["day", "hour", "minute", "second"]).default("day"),
+  hourCycle: zod.z.union([zod.z.literal(12), zod.z.literal(24)]).optional(),
+  hideTimeZone: zod.z.boolean().optional(),
+  shouldForceLeadingZeros: zod.z.boolean().optional(),
+  // Constraint props
+  minValue: zod.z.custom().optional(),
+  maxValue: zod.z.custom().optional(),
+  // State props
+  isDisabled: zod.z.boolean().optional(),
+  isReadOnly: zod.z.boolean().optional(),
+  isRequired: zod.z.boolean().optional(),
+  isInvalid: zod.z.boolean().optional(),
+  // Validation props
+  /** Custom validation function that returns an error message or null */
+  validate: zod.z.function().optional(),
+  validationBehavior: zod.z.enum(["native", "aria"]).default("native"),
+  // Display props
+  label: zod.z.string(),
+  description: zod.z.string().optional(),
+  /** Error message string or render function */
+  errorMessage: zod.z.union([zod.z.string(), zod.z.function()]).optional(),
+  // Form props
+  name: zod.z.string().optional(),
+  // Variant props
+  size: zod.z.enum(["sm", "default", "lg"]).default("default"),
+  // Event props
+  /** Called when the date value changes */
+  onChange: zod.z.function().optional(),
+  /** Called when the field gains focus */
+  onFocus: zod.z.function().optional(),
+  /** Called when the field loses focus */
+  onBlur: zod.z.function().optional(),
+  /** Called when focus state changes */
+  onFocusChange: zod.z.function().optional(),
+  // Standard props
+  className: zod.z.string().optional()
 });
-Object.defineProperty(exports, "DateRangePicker", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.DateRangePicker; }
+var CalendarPropsSchema = zod.z.object({
+  // Value props
+  value: zod.z.custom().optional(),
+  defaultValue: zod.z.custom().optional(),
+  focusedValue: zod.z.custom().optional(),
+  defaultFocusedValue: zod.z.custom().optional(),
+  // Constraint props
+  minValue: zod.z.custom().optional(),
+  maxValue: zod.z.custom().optional(),
+  /** Callback to determine if a specific date is unavailable for selection */
+  isDateUnavailable: zod.z.function().optional(),
+  // State props
+  isDisabled: zod.z.boolean().optional(),
+  isReadOnly: zod.z.boolean().optional(),
+  // Calendar props
+  firstDayOfWeek: zod.z.enum(["sun", "mon", "tue", "wed", "thu", "fri", "sat"]).optional(),
+  pageBehavior: zod.z.enum(["single", "visible"]).optional(),
+  visibleDuration: zod.z.object({ months: zod.z.number() }).optional(),
+  // Variant props
+  size: zod.z.enum(["sm", "default", "lg"]).default("default"),
+  // Event props
+  /** Called when the date value changes */
+  onChange: zod.z.function().optional(),
+  /** Called when the focused date changes */
+  onFocusChange: zod.z.function().optional(),
+  // Standard props
+  className: zod.z.string().optional()
 });
-Object.defineProperty(exports, "DateRangePickerPropsSchema", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.DateRangePickerPropsSchema; }
-});
-Object.defineProperty(exports, "RangeCalendarPropsSchema", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.RangeCalendarPropsSchema; }
-});
-Object.defineProperty(exports, "calendarCellVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.calendarCellVariants; }
-});
-Object.defineProperty(exports, "calendarGridHeaderCellVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.calendarGridHeaderCellVariants; }
-});
-Object.defineProperty(exports, "calendarGridVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.calendarGridVariants; }
-});
-Object.defineProperty(exports, "calendarHeaderVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.calendarHeaderVariants; }
-});
-Object.defineProperty(exports, "calendarNavButtonVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.calendarNavButtonVariants; }
-});
-Object.defineProperty(exports, "dateFieldVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.dateFieldVariants; }
-});
-Object.defineProperty(exports, "datePickerDescriptionVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.datePickerDescriptionVariants; }
-});
-Object.defineProperty(exports, "datePickerErrorVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.datePickerErrorVariants; }
-});
-Object.defineProperty(exports, "datePickerLabelVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.datePickerLabelVariants; }
-});
-Object.defineProperty(exports, "datePickerPopoverVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.datePickerPopoverVariants; }
-});
-Object.defineProperty(exports, "datePickerTriggerVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.datePickerTriggerVariants; }
-});
-Object.defineProperty(exports, "dateSegmentVariants", {
-  enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.dateSegmentVariants; }
+var RangeCalendarPropsSchema = CalendarPropsSchema.omit({
+  value: true,
+  defaultValue: true,
+  onChange: true
+}).extend({
+  // Range value props
+  value: zod.z.object({
+    start: zod.z.custom(),
+    end: zod.z.custom()
+  }).optional(),
+  defaultValue: zod.z.object({
+    start: zod.z.custom(),
+    end: zod.z.custom()
+  }).optional(),
+  // Range event props
+  /** Called when the date range value changes */
+  onChange: zod.z.function().optional()
 });
+
 Object.defineProperty(exports, "getLocalTimeZone", {
   enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.getLocalTimeZone; }
+  get: function () { return date.getLocalTimeZone; }
 });
 Object.defineProperty(exports, "isWeekend", {
   enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.isWeekend; }
+  get: function () { return date.isWeekend; }
 });
 Object.defineProperty(exports, "now", {
   enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.now; }
+  get: function () { return date.now; }
 });
 Object.defineProperty(exports, "parseDate", {
   enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.parseDate; }
+  get: function () { return date.parseDate; }
 });
 Object.defineProperty(exports, "parseDateTime", {
   enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.parseDateTime; }
+  get: function () { return date.parseDateTime; }
 });
 Object.defineProperty(exports, "parseZonedDateTime", {
   enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.parseZonedDateTime; }
+  get: function () { return date.parseZonedDateTime; }
 });
 Object.defineProperty(exports, "today", {
   enumerable: true,
-  get: function () { return chunkZP2KV6EX_js.today; }
+  get: function () { return date.today; }
 });
+exports.Calendar = Calendar;
+exports.CalendarPropsSchema = CalendarPropsSchema;
+exports.DateField = DateField;
+exports.DateFieldPropsSchema = DateFieldPropsSchema;
+exports.DatePicker = DatePicker;
+exports.DatePickerPropsSchema = DatePickerPropsSchema;
+exports.DateRangePicker = DateRangePicker;
+exports.DateRangePickerPropsSchema = DateRangePickerPropsSchema;
+exports.RangeCalendarPropsSchema = RangeCalendarPropsSchema;
+exports.calendarCellVariants = calendarCellVariants;
+exports.calendarGridHeaderCellVariants = calendarGridHeaderCellVariants;
+exports.calendarGridVariants = calendarGridVariants;
+exports.calendarHeaderVariants = calendarHeaderVariants;
+exports.calendarNavButtonVariants = calendarNavButtonVariants;
+exports.dateFieldVariants = dateFieldVariants;
+exports.datePickerDescriptionVariants = datePickerDescriptionVariants;
+exports.datePickerErrorVariants = datePickerErrorVariants;
+exports.datePickerLabelVariants = datePickerLabelVariants;
+exports.datePickerPopoverVariants = datePickerPopoverVariants;
+exports.datePickerTriggerVariants = datePickerTriggerVariants;
+exports.dateSegmentVariants = dateSegmentVariants;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map