@letar/forms 1.0.3 → 1.2.0

package/chunk-Q5EOF36Y.js

@@ -0,0 +1,709 @@
+import { createField, FieldWrapper, FieldLabel, FieldError, getFieldErrors, useResolvedFieldProps } from './chunk-XFWLD5EO.js';
+import { Input, Field, Flex, HStack, Box, Menu, Button, Portal, NumberInput, Text, Stack } from '@chakra-ui/react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { LuCalendar, LuChevronDown } from 'react-icons/lu';
+import { memo, useMemo, useCallback } from 'react';
+
+var FieldDate = createField({
+  displayName: "FieldDate",
+  render: ({ field, fullPath, resolved, hasError, errorMessage, componentProps }) => {
+    const { constraints } = resolved;
+    const rawValue = field.state.value;
+    let stringValue = "";
+    if (rawValue instanceof Date) {
+      stringValue = rawValue.toISOString().split("T")[0];
+    } else if (typeof rawValue === "string") {
+      stringValue = rawValue;
+    }
+    const min = componentProps.min ?? constraints.date?.min;
+    const max = componentProps.max ?? constraints.date?.max;
+    return /* @__PURE__ */ jsx(FieldWrapper, { resolved, hasError, errorMessage, fullPath, children: /* @__PURE__ */ jsx(
+      Input,
+      {
+        type: "date",
+        value: stringValue,
+        onChange: (e) => field.handleChange(e.target.value),
+        onBlur: field.handleBlur,
+        placeholder: resolved.placeholder,
+        min,
+        max,
+        "data-field-name": fullPath
+      }
+    ) });
+  }
+});
+function getPresetRange(preset) {
+  const today = /* @__PURE__ */ new Date();
+  const formatDate = (d) => d.toISOString().split("T")[0];
+  switch (preset) {
+    case "today":
+      return { start: formatDate(today), end: formatDate(today) };
+    case "yesterday": {
+      const yesterday = new Date(today);
+      yesterday.setDate(today.getDate() - 1);
+      return { start: formatDate(yesterday), end: formatDate(yesterday) };
+    }
+    case "thisWeek": {
+      const startOfWeek = new Date(today);
+      startOfWeek.setDate(today.getDate() - today.getDay() + 1);
+      const endOfWeek = new Date(startOfWeek);
+      endOfWeek.setDate(startOfWeek.getDate() + 6);
+      return { start: formatDate(startOfWeek), end: formatDate(endOfWeek) };
+    }
+    case "lastWeek": {
+      const startOfLastWeek = new Date(today);
+      startOfLastWeek.setDate(today.getDate() - today.getDay() - 6);
+      const endOfLastWeek = new Date(startOfLastWeek);
+      endOfLastWeek.setDate(startOfLastWeek.getDate() + 6);
+      return { start: formatDate(startOfLastWeek), end: formatDate(endOfLastWeek) };
+    }
+    case "thisMonth": {
+      const startOfMonth = new Date(today.getFullYear(), today.getMonth(), 1);
+      const endOfMonth = new Date(today.getFullYear(), today.getMonth() + 1, 0);
+      return { start: formatDate(startOfMonth), end: formatDate(endOfMonth) };
+    }
+    case "lastMonth": {
+      const startOfLastMonth = new Date(today.getFullYear(), today.getMonth() - 1, 1);
+      const endOfLastMonth = new Date(today.getFullYear(), today.getMonth(), 0);
+      return { start: formatDate(startOfLastMonth), end: formatDate(endOfLastMonth) };
+    }
+    case "thisYear": {
+      const startOfYear = new Date(today.getFullYear(), 0, 1);
+      const endOfYear = new Date(today.getFullYear(), 11, 31);
+      return { start: formatDate(startOfYear), end: formatDate(endOfYear) };
+    }
+  }
+}
+function getPresetLabel(preset) {
+  switch (preset) {
+    case "today":
+      return "Today";
+    case "yesterday":
+      return "Yesterday";
+    case "thisWeek":
+      return "This week";
+    case "lastWeek":
+      return "Last week";
+    case "thisMonth":
+      return "This month";
+    case "lastMonth":
+      return "Last month";
+    case "thisYear":
+      return "This year";
+  }
+}
+var FieldDateRange = createField({
+  displayName: "FieldDateRange",
+  render: ({ field, fullPath, resolved, hasError, errorMessage, componentProps }) => {
+    const {
+      startLabel = "Start",
+      endLabel = "End",
+      startPlaceholder,
+      endPlaceholder,
+      min,
+      max,
+      presets,
+      orientation = "horizontal",
+      size = "md"
+    } = componentProps;
+    const value = field.state.value ?? { start: "", end: "" };
+    const handleStartChange = (newStart) => {
+      field.handleChange({ ...value, start: newStart });
+    };
+    const handleEndChange = (newEnd) => {
+      field.handleChange({ ...value, end: newEnd });
+    };
+    const handlePreset = (preset) => {
+      field.handleChange(getPresetRange(preset));
+    };
+    const Container = orientation === "horizontal" ? HStack : Box;
+    return /* @__PURE__ */ jsxs(
+      Field.Root,
+      {
+        invalid: hasError,
+        required: resolved.required,
+        disabled: resolved.disabled,
+        readOnly: resolved.readOnly,
+        children: [
+          /* @__PURE__ */ jsx(FieldLabel, { label: resolved.label, tooltip: resolved.tooltip, required: resolved.required }),
+          /* @__PURE__ */ jsxs(Flex, { gap: 2, direction: orientation === "horizontal" ? "row" : "column", align: "stretch", width: "full", children: [
+            /* @__PURE__ */ jsxs(Container, { gap: 2, flex: 1, alignItems: "flex-end", children: [
+              /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsxs(Field.Root, { disabled: resolved.disabled, readOnly: resolved.readOnly, children: [
+                /* @__PURE__ */ jsx(Field.Label, { fontSize: "sm", color: "fg.muted", children: startLabel }),
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    type: "date",
+                    value: value.start,
+                    onChange: (e) => handleStartChange(e.target.value),
+                    onBlur: field.handleBlur,
+                    placeholder: startPlaceholder,
+                    min,
+                    max: value.end || max,
+                    size,
+                    "data-field-name": `${fullPath}.start`
+                  }
+                )
+              ] }) }),
+              /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsxs(Field.Root, { disabled: resolved.disabled, readOnly: resolved.readOnly, children: [
+                /* @__PURE__ */ jsx(Field.Label, { fontSize: "sm", color: "fg.muted", children: endLabel }),
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    type: "date",
+                    value: value.end,
+                    onChange: (e) => handleEndChange(e.target.value),
+                    onBlur: field.handleBlur,
+                    placeholder: endPlaceholder,
+                    min: value.start || min,
+                    max,
+                    size,
+                    "data-field-name": `${fullPath}.end`
+                  }
+                )
+              ] }) })
+            ] }),
+            presets && presets.length > 0 && !resolved.readOnly && /* @__PURE__ */ jsxs(Menu.Root, { children: [
+              /* @__PURE__ */ jsx(Menu.Trigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "outline", size, disabled: resolved.disabled, children: [
+                /* @__PURE__ */ jsx(LuCalendar, {}),
+                "Presets",
+                /* @__PURE__ */ jsx(LuChevronDown, {})
+              ] }) }),
+              /* @__PURE__ */ jsx(Portal, { children: /* @__PURE__ */ jsx(Menu.Positioner, { children: /* @__PURE__ */ jsx(Menu.Content, { children: presets.map((preset) => /* @__PURE__ */ jsx(Menu.Item, { value: preset, onClick: () => handlePreset(preset), children: getPresetLabel(preset) }, preset)) }) }) })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage, helperText: resolved.helperText })
+        ]
+      }
+    );
+  }
+});
+function parseDateTime(value) {
+  if (!value) {
+    return { date: "", time: "" };
+  }
+  const match = value.match(/^(\d{4}-\d{2}-\d{2})(?:T(\d{2}:\d{2}))?/);
+  if (match) {
+    return { date: match[1], time: match[2] || "" };
+  }
+  return { date: "", time: "" };
+}
+function combineDateTime(date, time) {
+  if (!date) {
+    return "";
+  }
+  if (!time) {
+    return date;
+  }
+  return `${date}T${time}:00`;
+}
+var FieldDateTimePicker = createField({
+  displayName: "FieldDateTimePicker",
+  render: ({ field, fullPath, resolved, hasError, errorMessage, componentProps }) => {
+    const { minDateTime, maxDateTime, timeStep = 15 } = componentProps;
+    const minDateTimeStr = minDateTime instanceof Date ? minDateTime.toISOString().slice(0, 16) : minDateTime?.slice(0, 16);
+    const maxDateTimeStr = maxDateTime instanceof Date ? maxDateTime.toISOString().slice(0, 16) : maxDateTime?.slice(0, 16);
+    const minDate = minDateTimeStr?.slice(0, 10);
+    const maxDate = maxDateTimeStr?.slice(0, 10);
+    const value = field.state.value;
+    const { date, time } = parseDateTime(value);
+    const handleDateChange = (newDate) => {
+      const combined = combineDateTime(newDate, time);
+      field.handleChange(combined || void 0);
+    };
+    const handleTimeChange = (newTime) => {
+      const combined = combineDateTime(date, newTime);
+      field.handleChange(combined || void 0);
+    };
+    return /* @__PURE__ */ jsxs(
+      Field.Root,
+      {
+        invalid: hasError,
+        required: resolved.required,
+        disabled: resolved.disabled,
+        readOnly: resolved.readOnly,
+        children: [
+          /* @__PURE__ */ jsx(FieldLabel, { label: resolved.label, tooltip: resolved.tooltip, required: resolved.required }),
+          /* @__PURE__ */ jsxs(HStack, { gap: 2, children: [
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                type: "date",
+                value: date,
+                onChange: (e) => handleDateChange(e.target.value),
+                onBlur: field.handleBlur,
+                min: minDate,
+                max: maxDate,
+                "data-field-name": `${fullPath}-date`,
+                flex: 1
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                type: "time",
+                value: time,
+                onChange: (e) => handleTimeChange(e.target.value),
+                onBlur: field.handleBlur,
+                step: timeStep * 60,
+                "data-field-name": `${fullPath}-time`,
+                width: "150px"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage, helperText: resolved.helperText })
+        ]
+      }
+    );
+  }
+});
+function minutesToHHMM(minutes) {
+  return {
+    hours: Math.floor(minutes / 60),
+    mins: minutes % 60
+  };
+}
+function hhmmToMinutes(hours, mins) {
+  return hours * 60 + mins;
+}
+var FieldDuration = createField({
+  displayName: "FieldDuration",
+  render: ({ field, fullPath, resolved, hasError, errorMessage, componentProps }) => {
+    const { format = "HH:MM", min = 0, max = 1440, step = 15 } = componentProps;
+    const value = field.state.value ?? 0;
+    const { hours, mins } = minutesToHHMM(value);
+    const handleHoursChange = (newHours) => {
+      const newValue = hhmmToMinutes(newHours, mins);
+      const clampedValue = Math.max(min, Math.min(max, newValue));
+      field.handleChange(clampedValue);
+    };
+    const handleMinsChange = (newMins) => {
+      const newValue = hhmmToMinutes(hours, newMins);
+      const clampedValue = Math.max(min, Math.min(max, newValue));
+      field.handleChange(clampedValue);
+    };
+    const handleMinutesChange = (newValue) => {
+      const clampedValue = Math.max(min, Math.min(max, newValue));
+      field.handleChange(clampedValue);
+    };
+    if (format === "minutes") {
+      return /* @__PURE__ */ jsxs(
+        Field.Root,
+        {
+          invalid: hasError,
+          required: resolved.required,
+          disabled: resolved.disabled,
+          readOnly: resolved.readOnly,
+          children: [
+            /* @__PURE__ */ jsx(FieldLabel, { label: resolved.label, tooltip: resolved.tooltip, required: resolved.required }),
+            /* @__PURE__ */ jsxs(
+              NumberInput.Root,
+              {
+                value: value.toString(),
+                onValueChange: (details) => {
+                  const num = details.valueAsNumber;
+                  if (!Number.isNaN(num)) {
+                    handleMinutesChange(num);
+                  }
+                },
+                onBlur: field.handleBlur,
+                min,
+                max,
+                step,
+                children: [
+                  /* @__PURE__ */ jsxs(NumberInput.Control, { children: [
+                    /* @__PURE__ */ jsx(NumberInput.IncrementTrigger, {}),
+                    /* @__PURE__ */ jsx(NumberInput.DecrementTrigger, {})
+                  ] }),
+                  /* @__PURE__ */ jsx(NumberInput.Input, { placeholder: resolved.placeholder ?? "min", "data-field-name": fullPath })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage, helperText: resolved.helperText })
+          ]
+        }
+      );
+    }
+    return /* @__PURE__ */ jsxs(
+      Field.Root,
+      {
+        invalid: hasError,
+        required: resolved.required,
+        disabled: resolved.disabled,
+        readOnly: resolved.readOnly,
+        children: [
+          /* @__PURE__ */ jsx(FieldLabel, { label: resolved.label, tooltip: resolved.tooltip, required: resolved.required }),
+          /* @__PURE__ */ jsxs(HStack, { gap: 2, children: [
+            /* @__PURE__ */ jsxs(
+              NumberInput.Root,
+              {
+                value: hours.toString(),
+                onValueChange: (details) => {
+                  const num = details.valueAsNumber;
+                  if (!Number.isNaN(num)) {
+                    handleHoursChange(num);
+                  }
+                },
+                onBlur: field.handleBlur,
+                min: 0,
+                max: Math.floor(max / 60),
+                width: "80px",
+                children: [
+                  /* @__PURE__ */ jsxs(NumberInput.Control, { children: [
+                    /* @__PURE__ */ jsx(NumberInput.IncrementTrigger, {}),
+                    /* @__PURE__ */ jsx(NumberInput.DecrementTrigger, {})
+                  ] }),
+                  /* @__PURE__ */ jsx(NumberInput.Input, { "data-field-name": `${fullPath}-hours` })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(Text, { fontWeight: "bold", children: ":" }),
+            /* @__PURE__ */ jsxs(
+              NumberInput.Root,
+              {
+                value: mins.toString().padStart(2, "0"),
+                onValueChange: (details) => {
+                  const num = details.valueAsNumber;
+                  if (!Number.isNaN(num)) {
+                    handleMinsChange(num);
+                  }
+                },
+                onBlur: field.handleBlur,
+                min: 0,
+                max: 59,
+                step,
+                width: "80px",
+                children: [
+                  /* @__PURE__ */ jsxs(NumberInput.Control, { children: [
+                    /* @__PURE__ */ jsx(NumberInput.IncrementTrigger, {}),
+                    /* @__PURE__ */ jsx(NumberInput.DecrementTrigger, {})
+                  ] }),
+                  /* @__PURE__ */ jsx(NumberInput.Input, { "data-field-name": `${fullPath}-mins` })
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage, helperText: resolved.helperText })
+        ]
+      }
+    );
+  }
+});
+var DAYS_OF_WEEK = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+var DEFAULT_DAY_NAMES = {
+  monday: "Monday",
+  tuesday: "Tuesday",
+  wednesday: "Wednesday",
+  thursday: "Thursday",
+  friday: "Friday",
+  saturday: "Saturday",
+  sunday: "Sunday"
+};
+var DEFAULT_WORKING_HOURS = {
+  monday: { open: "09:00", close: "18:00" },
+  tuesday: { open: "09:00", close: "18:00" },
+  wednesday: { open: "09:00", close: "18:00" },
+  thursday: { open: "09:00", close: "18:00" },
+  friday: { open: "09:00", close: "18:00" },
+  saturday: null,
+  sunday: null
+};
+var SWITCH_STYLES = {
+  /** Switch track width */
+  trackWidth: "36px",
+  /** Switch track height */
+  trackHeight: "20px",
+  /** Round indicator (thumb) size */
+  thumbSize: "16px",
+  /** Thumb offset from edge (2px each side for centering in 20px track) */
+  thumbOffset: "2px",
+  /** Thumb position in enabled state (trackWidth - thumbSize - thumbOffset = 36 - 16 - 2 = 18) */
+  thumbEnabledLeft: "18px"
+};
+function isValidTimeRange(open, close) {
+  const [openH, openM] = open.split(":").map(Number);
+  const [closeH, closeM] = close.split(":").map(Number);
+  const openMinutes = openH * 60 + openM;
+  const closeMinutes = closeH * 60 + closeM;
+  return closeMinutes > openMinutes;
+}
+var ScheduleContent = memo(function ScheduleContent2({
+  field,
+  schedule,
+  days,
+  mergedDayNames,
+  showCopyToWeekdays,
+  offLabel,
+  copyToWeekdaysLabel,
+  defaultOpenTime,
+  defaultCloseTime,
+  disabled,
+  readOnly,
+  resolvedLabel,
+  resolvedHelperText,
+  resolvedRequired,
+  resolvedTooltip,
+  fullPath
+}) {
+  const { hasError, errorMessage } = getFieldErrors(field);
+  const invalidDays = useMemo(() => {
+    const invalid = [];
+    for (const day of days) {
+      const daySchedule = schedule[day];
+      if (daySchedule && !isValidTimeRange(daySchedule.open, daySchedule.close)) {
+        invalid.push(day);
+      }
+    }
+    return invalid;
+  }, [schedule, days]);
+  const handleDayToggle = useCallback(
+    (day, enabled) => {
+      const newSchedule = {
+        ...schedule,
+        [day]: enabled ? { open: defaultOpenTime, close: defaultCloseTime } : null
+      };
+      field.handleChange(newSchedule);
+    },
+    [schedule, field, defaultOpenTime, defaultCloseTime]
+  );
+  const handleTimeChange = useCallback(
+    (day, timeField, value) => {
+      const current = schedule[day];
+      if (!current) {
+        return;
+      }
+      const newSchedule = {
+        ...schedule,
+        [day]: { ...current, [timeField]: value }
+      };
+      field.handleChange(newSchedule);
+    },
+    [schedule, field]
+  );
+  const handleCopyToWeekdays = useCallback(() => {
+    const mondaySchedule = schedule.monday;
+    if (!mondaySchedule) {
+      return;
+    }
+    const newSchedule = {
+      ...schedule,
+      monday: mondaySchedule,
+      tuesday: mondaySchedule,
+      wednesday: mondaySchedule,
+      thursday: mondaySchedule,
+      friday: mondaySchedule
+    };
+    field.handleChange(newSchedule);
+  }, [schedule, field]);
+  return /* @__PURE__ */ jsxs(
+    Field.Root,
+    {
+      invalid: hasError,
+      required: resolvedRequired,
+      disabled,
+      readOnly,
+      "data-field-name": fullPath,
+      children: [
+        /* @__PURE__ */ jsx(FieldLabel, { label: resolvedLabel, tooltip: resolvedTooltip, required: resolvedRequired }),
+        /* @__PURE__ */ jsxs(Stack, { gap: 3, children: [
+          invalidDays.length > 0 && /* @__PURE__ */ jsx(Box, { p: 3, bg: "red.50", borderWidth: "1px", borderColor: "red.200", borderRadius: "md", children: /* @__PURE__ */ jsxs(Text, { color: "red.600", fontSize: "sm", fontWeight: "medium", children: [
+            "End time must be after start time: ",
+            invalidDays.map((d) => mergedDayNames[d]).join(", ")
+          ] }) }),
+          showCopyToWeekdays && days.includes("monday") && /* @__PURE__ */ jsxs(HStack, { gap: 2, flexWrap: "wrap", children: [
+            /* @__PURE__ */ jsx(Text, { fontSize: "sm", color: "fg.muted", children: "Quick actions:" }),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                type: "button",
+                size: "xs",
+                variant: "ghost",
+                colorPalette: "blue",
+                onClick: handleCopyToWeekdays,
+                disabled: disabled || readOnly || !schedule.monday,
+                children: copyToWeekdaysLabel
+              }
+            )
+          ] }),
+          days.map((day) => {
+            const daySchedule = schedule[day];
+            const isEnabled = daySchedule !== null && daySchedule !== void 0;
+            const dayHasError = invalidDays.includes(day);
+            return /* @__PURE__ */ jsx(
+              Box,
+              {
+                "data-day": day,
+                p: 3,
+                bg: dayHasError ? "red.50" : isEnabled ? "bg.panel" : "bg.muted",
+                borderRadius: "md",
+                borderWidth: dayHasError ? "2px" : "1px",
+                borderColor: dayHasError ? "red.300" : "border.muted",
+                children: /* @__PURE__ */ jsxs(HStack, { justify: "space-between", flexWrap: "wrap", gap: 3, children: [
+                  /* @__PURE__ */ jsxs(HStack, { gap: 3, minW: "140px", children: [
+                    /* @__PURE__ */ jsxs(
+                      Box,
+                      {
+                        as: "label",
+                        display: "inline-flex",
+                        alignItems: "center",
+                        cursor: disabled || readOnly ? "not-allowed" : "pointer",
+                        position: "relative",
+                        opacity: disabled || readOnly ? 0.4 : 1,
+                        children: [
+                          /* @__PURE__ */ jsx(
+                            "input",
+                            {
+                              type: "checkbox",
+                              checked: isEnabled,
+                              onChange: (e) => handleDayToggle(day, e.target.checked),
+                              disabled: disabled || readOnly,
+                              "data-switch": day,
+                              style: {
+                                position: "absolute",
+                                opacity: 0,
+                                width: 0,
+                                height: 0
+                              }
+                            }
+                          ),
+                          /* @__PURE__ */ jsx(
+                            Box,
+                            {
+                              w: SWITCH_STYLES.trackWidth,
+                              h: SWITCH_STYLES.trackHeight,
+                              bg: isEnabled ? "green.500" : "gray.300",
+                              borderRadius: "full",
+                              position: "relative",
+                              transition: "background 0.2s",
+                              children: /* @__PURE__ */ jsx(
+                                Box,
+                                {
+                                  position: "absolute",
+                                  top: SWITCH_STYLES.thumbOffset,
+                                  left: isEnabled ? SWITCH_STYLES.thumbEnabledLeft : SWITCH_STYLES.thumbOffset,
+                                  w: SWITCH_STYLES.thumbSize,
+                                  h: SWITCH_STYLES.thumbSize,
+                                  bg: "white",
+                                  borderRadius: "full",
+                                  transition: "left 0.2s",
+                                  boxShadow: "sm"
+                                }
+                              )
+                            }
+                          )
+                        ]
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(Text, { fontWeight: "medium", color: isEnabled ? "fg" : "fg.muted", children: mergedDayNames[day] })
+                  ] }),
+                  isEnabled ? /* @__PURE__ */ jsxs(HStack, { gap: 2, children: [
+                    /* @__PURE__ */ jsx(
+                      Input,
+                      {
+                        type: "time",
+                        size: "sm",
+                        width: "120px",
+                        value: daySchedule?.open || defaultOpenTime,
+                        onChange: (e) => handleTimeChange(day, "open", e.target.value),
+                        disabled: disabled || readOnly
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(Text, { color: "fg.muted", children: "\u2014" }),
+                    /* @__PURE__ */ jsx(
+                      Input,
+                      {
+                        type: "time",
+                        size: "sm",
+                        width: "120px",
+                        value: daySchedule?.close || defaultCloseTime,
+                        onChange: (e) => handleTimeChange(day, "close", e.target.value),
+                        disabled: disabled || readOnly
+                      }
+                    )
+                  ] }) : /* @__PURE__ */ jsx(Text, { fontSize: "sm", color: "fg.muted", children: offLabel })
+                ] })
+              },
+              day
+            );
+          })
+        ] }),
+        /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage, helperText: resolvedHelperText })
+      ]
+    }
+  );
+});
+function FieldSchedule({
+  name,
+  label,
+  helperText,
+  required,
+  disabled,
+  readOnly,
+  tooltip,
+  dayNames = {},
+  defaultSchedule = DEFAULT_WORKING_HOURS,
+  days = DAYS_OF_WEEK,
+  showCopyToWeekdays = true,
+  offLabel = "Day off",
+  copyToWeekdaysLabel = "Copy Mon to weekdays",
+  defaultOpenTime = "09:00",
+  defaultCloseTime = "18:00"
+}) {
+  const {
+    form,
+    fullPath,
+    label: resolvedLabel,
+    helperText: resolvedHelperText,
+    tooltip: resolvedTooltip,
+    required: resolvedRequired,
+    disabled: resolvedDisabled,
+    readOnly: resolvedReadOnly
+  } = useResolvedFieldProps(name, { label, helperText, required, disabled, readOnly, tooltip });
+  const mergedDayNames = { ...DEFAULT_DAY_NAMES, ...dayNames };
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => {
+    const schedule = field.state.value || defaultSchedule;
+    return /* @__PURE__ */ jsx(
+      ScheduleContent,
+      {
+        field,
+        schedule,
+        defaultSchedule,
+        days,
+        mergedDayNames,
+        showCopyToWeekdays,
+        offLabel,
+        copyToWeekdaysLabel,
+        defaultOpenTime,
+        defaultCloseTime,
+        disabled: resolvedDisabled,
+        readOnly: resolvedReadOnly,
+        resolvedLabel,
+        resolvedHelperText,
+        resolvedRequired,
+        resolvedTooltip,
+        fullPath
+      }
+    );
+  } });
+}
+var FieldTime = createField({
+  displayName: "FieldTime",
+  render: ({ field, fullPath, resolved, hasError, errorMessage, componentProps }) => /* @__PURE__ */ jsx(FieldWrapper, { resolved, hasError, errorMessage, fullPath, children: /* @__PURE__ */ jsx(
+    Input,
+    {
+      type: "time",
+      value: field.state.value ?? "",
+      onChange: (e) => field.handleChange(e.target.value),
+      onBlur: field.handleBlur,
+      placeholder: resolved.placeholder,
+      min: componentProps.min,
+      max: componentProps.max,
+      step: componentProps.step,
+      "data-field-name": fullPath
+    }
+  ) })
+});
+
+export { FieldDate, FieldDateRange, FieldDateTimePicker, FieldDuration, FieldSchedule, FieldTime };
+//# sourceMappingURL=chunk-Q5EOF36Y.js.map
+//# sourceMappingURL=chunk-Q5EOF36Y.js.map