@rachelallyson/hero-hook-form 2.9.0 → 2.9.2

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.9.2] - 2026-01-28
+
+### Added
+
+- **Date field: Date and ISO string default values** – You can pass a normal JavaScript `Date` or an ISO date string (e.g. `"2025-03-20"`) in `defaultValues` for date fields; the library converts them to `CalendarDate` for HeroUI DateInput.
+- **Shared date coercion** – New `toCalendarDateValue()` in `utils/dateCoercion.ts`; used by `DateField` and `ServerActionForm` so date inputs always receive a valid `CalendarDate | null` and no longer throw "Invalid granularity day" for raw `Date` values.
+- **ConfigProvider: DateInput common defaults** – Date inputs now receive the same `common` defaults (variant, size, radius, labelPlacement) as Input, Textarea, and Select when using `HeroHookFormProvider` with `defaults.common`.
+- **useZodForm** – Merges field-level `defaultValue` from field configs into form `defaultValues`; date values in `config.defaultValues` are converted to `CalendarDate` for date fields.
+- **Docs: Date Input Demo** – Demo page showing Date vs ISO string defaults, shared styles via HeroHookFormProvider, and ZodForm with date defaults.
+
+### Fixed
+
+- **Date input default value** – Default values for date fields now work when set via `config.defaultValues`; Date/string values are converted to `CalendarDate`.
+- **Date input styling** – DateInput now receives `common` styling from ConfigProvider so it matches other inputs when using `HeroHookFormProvider`.
+- **"Invalid granularity day" error** – DateField and ServerActionForm coerce Date/string to CalendarDate before passing to HeroUI DateInput, fixing the console error when defaultValues used raw `Date` or the server wasn’t restarted after package changes.
+- **useZodForm config mutation** – Resolver is no longer assigned onto the caller’s config object; a new options object is built instead.
+- **Lint** – Removed unused `shouldRenderConditionalField` (FormField), fixed unused catch binding and type params (fieldArrayMemory).
+
+## [2.9.1] - 2026-01-28
+
+### Fixed
+
+- **Cypress Testing: fillInputByLabel clearing behavior**: Fixed issue where `fillInputByLabel` may not properly clear number inputs with default values
+  - Refactored to use a single chain ensuring clear operation completes before typing
+  - Ensures reliable clearing of all input types, especially number inputs with default values
+  - Clearing is now explicitly documented as the default behavior
+
 ## [2.9.0] - 2026-01-22
 
 ### Added

package/dist/cypress/index.js

@@ -334,7 +334,7 @@ var init_utils = __esm({
 });
 
 // src/cypress/helpers.ts
-function fillInputByName(name, value, options = {}) {
+function fillInputByName(name, value, options = { clear: true }) {
   return withRetry(() => {
     waitForFormReady();
     const element = cy.get(`input[name="${name}"], textarea[name="${name}"]`, { timeout: DEFAULT_CONFIG.timeout }).should("exist").should("be.visible");
@@ -347,7 +347,7 @@ function fillInputByName(name, value, options = {}) {
     });
   }, DEFAULT_CONFIG);
 }
-function fillInputByType(type, value, index = 0, options = {}) {
+function fillInputByType(type, value, index = 0, options = { clear: true }) {
   const selector = type === "textarea" ? buildHeroUISelector("textarea") : buildHeroUISelector("input", type);
   const element = index > 0 ? cy.get(selector).eq(index) : cy.get(selector).first();
   return withRetry(() => {
@@ -357,7 +357,7 @@ function fillInputByType(type, value, index = 0, options = {}) {
     return element.type(value, { force: true });
   }, DEFAULT_CONFIG);
 }
-function fillInputByPlaceholder(placeholder, value, options = {}) {
+function fillInputByPlaceholder(placeholder, value, options = { clear: true }) {
   const selector = `input[placeholder*="${placeholder}"], textarea[placeholder*="${placeholder}"]`;
   return withRetry(() => {
     const element = cy.get(selector);
@@ -367,17 +367,17 @@ function fillInputByPlaceholder(placeholder, value, options = {}) {
     return element.type(value, { force: true });
   }, DEFAULT_CONFIG);
 }
-function fillInputByLabel(label, value, options = {}) {
+function fillInputByLabel(label, value, options = { clear: true }) {
   return withRetry(() => {
-    return cy.contains("label", label).closest("div").find("input, textarea").first().then(($el) => {
-      if (options.clear !== false) {
-        cy.wrap($el).clear({ force: true });
-      }
-      return cy.wrap($el).type(value, { force: true });
-    });
+    const element = cy.contains("label", label).closest("div").find("input, textarea").first();
+    const shouldClear = options.clear !== false;
+    if (shouldClear) {
+      element.clear({ force: true });
+    }
+    return element.type(value, { force: true });
   }, DEFAULT_CONFIG);
 }
-function fillTextareaByName(name, value, options = {}) {
+function fillTextareaByName(name, value, options = { clear: true }) {
   return withRetry(() => {
     const element = cy.get(`textarea[name="${name}"]`);
     if (options.clear !== false) {
@@ -386,7 +386,7 @@ function fillTextareaByName(name, value, options = {}) {
     return element.type(value, { force: true });
   }, DEFAULT_CONFIG);
 }
-function fillTextarea(value, index = 0, options = {}) {
+function fillTextarea(value, index = 0, options = { clear: true }) {
   const selector = HERO_UI_SELECTORS.textarea;
   return withRetry(() => {
     const element = index > 0 ? cy.get(selector).eq(index) : cy.get(selector).first();

package/dist/index.d.ts

@@ -1773,7 +1773,8 @@ type TextareaDefaults = Partial<Omit<TextareaProps, "value" | "onValueChange" |
 type CheckboxDefaults = Partial<Omit<React$1.ComponentProps<typeof Checkbox>, "isSelected" | "onValueChange" | "isInvalid" | "errorMessage" | "isDisabled">>;
 type RadioGroupDefaults = Partial<Omit<React$1.ComponentProps<typeof RadioGroup>, "value" | "onValueChange" | "label">>;
 type SelectDefaults = Partial<Omit<SelectProps, "selectedKeys" | "onSelectionChange" | "label" | "isInvalid" | "errorMessage" | "isDisabled">>;
-type DateInputDefaults = Partial<Omit<React$1.ComponentProps<typeof DateInput>, "value" | "onValueChange" | "label" | "isInvalid" | "errorMessage" | "isDisabled">>;
+type DateInputProps = React$1.ComponentProps<typeof DateInput>;
+type DateInputDefaults = Partial<Omit<DateInputProps, "value" | "onChange" | "label" | "isInvalid" | "errorMessage" | "isDisabled">>;
 type SliderDefaults = Partial<Omit<React$1.ComponentProps<typeof Slider>, "value" | "onValueChange" | "label" | "isInvalid" | "errorMessage" | "isDisabled">>;
 type SwitchDefaults = Partial<Omit<React$1.ComponentProps<typeof Switch>, "isSelected" | "onValueChange" | "isInvalid" | "isDisabled">>;
 type ButtonDefaults = Partial<Omit<React$1.ComponentProps<typeof Button$1>, "type" | "isLoading">>;
@@ -2692,11 +2693,10 @@ declare const FormFieldHelpers: {
      * // Simple date field
      * FormFieldHelpers.date("birthDate", "Birth Date")
      *
-     * // With full customization
+     * // With DateInput props (set default via config.defaultValues)
      * FormFieldHelpers.date("birthDate", "Birth Date", {
-     *   label: "Select your birth date",
      *   granularity: "day",
-     *   minValue: new CalendarDate(1900, 1, 1)
+     *   minValue: new CalendarDate(1900, 1, 1),
      * })
      * ```
      */
@@ -4215,7 +4215,7 @@ declare const memorySafeFieldArray: {
     /**
      * Add items to a field array with memory management.
      */
-    addItems: <TFieldValues extends FieldValues>(append: (value: any) => void, items: any[], onProgress?: (addedCount: number) => void) => void;
+    addItems: (append: (value: any) => void, items: any[], onProgress?: (addedCount: number) => void) => void;
     /**
      * Clear entire field array with memory cleanup.
      */
@@ -4223,7 +4223,7 @@ declare const memorySafeFieldArray: {
     /**
      * Remove items from a field array with memory cleanup.
      */
-    removeItems: <TFieldValues extends FieldValues>(remove: (index: number) => void, indices: number[]) => void;
+    removeItems: (remove: (index: number) => void, indices: number[]) => void;
 };
 
 /**

package/dist/index.js

@@ -253,15 +253,49 @@ function extractSelectCommon(common) {
   }
   return result;
 }
+function extractDateInputCommon(common) {
+  const result = {};
+  if (common.color !== void 0) {
+    const color = common.color;
+    result.color = color;
+  }
+  if (common.size !== void 0) {
+    const size = common.size;
+    result.size = size;
+  }
+  if (common.variant !== void 0) {
+    const variant = common.variant;
+    result.variant = variant;
+  }
+  if (common.radius !== void 0) {
+    const radius = common.radius;
+    result.radius = radius;
+  }
+  if (common.labelPlacement !== void 0) {
+    const labelPlacement = common.labelPlacement;
+    result.labelPlacement = labelPlacement;
+  }
+  return result;
+}
 function useHeroHookFormDefaults() {
   const cfg = useContext(DefaultsContext) ?? {};
   const common = cfg.common ?? {};
   const commonInput = extractInputCommon(common);
   const commonTextarea = extractTextareaCommon(common);
   const commonSelect = extractSelectCommon(common);
+  const commonDateInput = extractDateInputCommon(common);
+  const dateInputBase = {
+    radius: "md",
+    size: "md",
+    variant: "bordered"
+  };
   return {
     checkbox: cfg.checkbox ?? {},
-    dateInput: cfg.dateInput ?? {},
+    dateInput: {
+      ...dateInputBase,
+      ...commonDateInput,
+      ...cfg.dateInput ?? {}
+    },
     input: { ...commonInput, ...cfg.input ?? {} },
     radioGroup: cfg.radioGroup ?? {},
     select: { ...commonSelect, ...cfg.select ?? {} },
@@ -446,9 +480,687 @@ function ContentField({
 // src/fields/DateField.tsx
 import React7 from "react";
 import { Controller as Controller4 } from "react-hook-form";
+
+// node_modules/@internationalized/date/dist/utils.mjs
+function $2b4dce13dd5a17fa$export$842a2cf37af977e1(amount, numerator) {
+  return amount - numerator * Math.floor(amount / numerator);
+}
+
+// node_modules/@internationalized/date/dist/GregorianCalendar.mjs
+var $3b62074eb05584b2$var$EPOCH = 1721426;
+function $3b62074eb05584b2$export$f297eb839006d339(era, year, month, day) {
+  year = $3b62074eb05584b2$export$c36e0ecb2d4fa69d(era, year);
+  let y1 = year - 1;
+  let monthOffset = -2;
+  if (month <= 2) monthOffset = 0;
+  else if ($3b62074eb05584b2$export$553d7fa8e3805fc0(year)) monthOffset = -1;
+  return $3b62074eb05584b2$var$EPOCH - 1 + 365 * y1 + Math.floor(y1 / 4) - Math.floor(y1 / 100) + Math.floor(y1 / 400) + Math.floor((367 * month - 362) / 12 + monthOffset + day);
+}
+function $3b62074eb05584b2$export$553d7fa8e3805fc0(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function $3b62074eb05584b2$export$c36e0ecb2d4fa69d(era, year) {
+  return era === "BC" ? 1 - year : year;
+}
+function $3b62074eb05584b2$export$4475b7e617eb123c(year) {
+  let era = "AD";
+  if (year <= 0) {
+    era = "BC";
+    year = 1 - year;
+  }
+  return [
+    era,
+    year
+  ];
+}
+var $3b62074eb05584b2$var$daysInMonth = {
+  standard: [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+  ],
+  leapyear: [
+    31,
+    29,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+  ]
+};
+var $3b62074eb05584b2$export$80ee6245ec4f29ec = class {
+  fromJulianDay(jd) {
+    let jd0 = jd;
+    let depoch = jd0 - $3b62074eb05584b2$var$EPOCH;
+    let quadricent = Math.floor(depoch / 146097);
+    let dqc = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(depoch, 146097);
+    let cent = Math.floor(dqc / 36524);
+    let dcent = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(dqc, 36524);
+    let quad = Math.floor(dcent / 1461);
+    let dquad = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(dcent, 1461);
+    let yindex = Math.floor(dquad / 365);
+    let extendedYear = quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
+    let [era, year] = $3b62074eb05584b2$export$4475b7e617eb123c(extendedYear);
+    let yearDay = jd0 - $3b62074eb05584b2$export$f297eb839006d339(era, year, 1, 1);
+    let leapAdj = 2;
+    if (jd0 < $3b62074eb05584b2$export$f297eb839006d339(era, year, 3, 1)) leapAdj = 0;
+    else if ($3b62074eb05584b2$export$553d7fa8e3805fc0(year)) leapAdj = 1;
+    let month = Math.floor(((yearDay + leapAdj) * 12 + 373) / 367);
+    let day = jd0 - $3b62074eb05584b2$export$f297eb839006d339(era, year, month, 1) + 1;
+    return new (0, $35ea8db9cb2ccb90$export$99faa760c7908e4f)(era, year, month, day);
+  }
+  toJulianDay(date) {
+    return $3b62074eb05584b2$export$f297eb839006d339(date.era, date.year, date.month, date.day);
+  }
+  getDaysInMonth(date) {
+    return $3b62074eb05584b2$var$daysInMonth[$3b62074eb05584b2$export$553d7fa8e3805fc0(date.year) ? "leapyear" : "standard"][date.month - 1];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getMonthsInYear(date) {
+    return 12;
+  }
+  getDaysInYear(date) {
+    return $3b62074eb05584b2$export$553d7fa8e3805fc0(date.year) ? 366 : 365;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getYearsInEra(date) {
+    return 9999;
+  }
+  getEras() {
+    return [
+      "BC",
+      "AD"
+    ];
+  }
+  isInverseEra(date) {
+    return date.era === "BC";
+  }
+  balanceDate(date) {
+    if (date.year <= 0) {
+      date.era = date.era === "BC" ? "AD" : "BC";
+      date.year = 1 - date.year;
+    }
+  }
+  constructor() {
+    this.identifier = "gregory";
+  }
+};
+
+// node_modules/@internationalized/date/dist/queries.mjs
+function $14e0f24ef4ac5c92$export$dbc69fd56b53d5e(a, b) {
+  var _a_isEqual, _b_isEqual;
+  var _a_isEqual1, _ref;
+  return (_ref = (_a_isEqual1 = (_a_isEqual = a.isEqual) === null || _a_isEqual === void 0 ? void 0 : _a_isEqual.call(a, b)) !== null && _a_isEqual1 !== void 0 ? _a_isEqual1 : (_b_isEqual = b.isEqual) === null || _b_isEqual === void 0 ? void 0 : _b_isEqual.call(b, a)) !== null && _ref !== void 0 ? _ref : a.identifier === b.identifier;
+}
+function $14e0f24ef4ac5c92$export$68781ddf31c0090f(a, b) {
+  return a.calendar.toJulianDay(a) - b.calendar.toJulianDay(b);
+}
+function $14e0f24ef4ac5c92$export$c19a80a9721b80f6(a, b) {
+  return $14e0f24ef4ac5c92$var$timeToMs(a) - $14e0f24ef4ac5c92$var$timeToMs(b);
+}
+function $14e0f24ef4ac5c92$var$timeToMs(a) {
+  return a.hour * 36e5 + a.minute * 6e4 + a.second * 1e3 + a.millisecond;
+}
+var $14e0f24ef4ac5c92$var$localTimeZone = null;
+function $14e0f24ef4ac5c92$export$aa8b41735afcabd2() {
+  if ($14e0f24ef4ac5c92$var$localTimeZone == null) $14e0f24ef4ac5c92$var$localTimeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return $14e0f24ef4ac5c92$var$localTimeZone;
+}
+
+// node_modules/@internationalized/date/dist/conversion.mjs
+function $11d87f3f76e88657$export$bd4fb2bc8bb06fb(date) {
+  date = $11d87f3f76e88657$export$b4a036af3fc0b032(date, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
+  let year = (0, $3b62074eb05584b2$export$c36e0ecb2d4fa69d)(date.era, date.year);
+  return $11d87f3f76e88657$var$epochFromParts(year, date.month, date.day, date.hour, date.minute, date.second, date.millisecond);
+}
+function $11d87f3f76e88657$var$epochFromParts(year, month, day, hour, minute, second, millisecond) {
+  let date = /* @__PURE__ */ new Date();
+  date.setUTCHours(hour, minute, second, millisecond);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getTime();
+}
+function $11d87f3f76e88657$export$59c99f3515d3493f(ms, timeZone) {
+  if (timeZone === "UTC") return 0;
+  if (ms > 0 && timeZone === (0, $14e0f24ef4ac5c92$export$aa8b41735afcabd2)()) return new Date(ms).getTimezoneOffset() * -6e4;
+  let { year, month, day, hour, minute, second } = $11d87f3f76e88657$var$getTimeZoneParts(ms, timeZone);
+  let utc = $11d87f3f76e88657$var$epochFromParts(year, month, day, hour, minute, second, 0);
+  return utc - Math.floor(ms / 1e3) * 1e3;
+}
+var $11d87f3f76e88657$var$formattersByTimeZone = /* @__PURE__ */ new Map();
+function $11d87f3f76e88657$var$getTimeZoneParts(ms, timeZone) {
+  let formatter = $11d87f3f76e88657$var$formattersByTimeZone.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hour12: false,
+      era: "short",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+    $11d87f3f76e88657$var$formattersByTimeZone.set(timeZone, formatter);
+  }
+  let parts = formatter.formatToParts(new Date(ms));
+  let namedParts = {};
+  for (let part of parts) if (part.type !== "literal") namedParts[part.type] = part.value;
+  return {
+    // Firefox returns B instead of BC... https://bugzilla.mozilla.org/show_bug.cgi?id=1752253
+    year: namedParts.era === "BC" || namedParts.era === "B" ? -namedParts.year + 1 : +namedParts.year,
+    month: +namedParts.month,
+    day: +namedParts.day,
+    hour: namedParts.hour === "24" ? 0 : +namedParts.hour,
+    minute: +namedParts.minute,
+    second: +namedParts.second
+  };
+}
+var $11d87f3f76e88657$var$DAYMILLIS = 864e5;
+function $11d87f3f76e88657$var$getValidWallTimes(date, timeZone, earlier, later) {
+  let found = earlier === later ? [
+    earlier
+  ] : [
+    earlier,
+    later
+  ];
+  return found.filter((absolute) => $11d87f3f76e88657$var$isValidWallTime(date, timeZone, absolute));
+}
+function $11d87f3f76e88657$var$isValidWallTime(date, timeZone, absolute) {
+  let parts = $11d87f3f76e88657$var$getTimeZoneParts(absolute, timeZone);
+  return date.year === parts.year && date.month === parts.month && date.day === parts.day && date.hour === parts.hour && date.minute === parts.minute && date.second === parts.second;
+}
+function $11d87f3f76e88657$export$5107c82f94518f5c(date, timeZone, disambiguation = "compatible") {
+  let dateTime = $11d87f3f76e88657$export$b21e0b124e224484(date);
+  if (timeZone === "UTC") return $11d87f3f76e88657$export$bd4fb2bc8bb06fb(dateTime);
+  if (timeZone === (0, $14e0f24ef4ac5c92$export$aa8b41735afcabd2)() && disambiguation === "compatible") {
+    dateTime = $11d87f3f76e88657$export$b4a036af3fc0b032(dateTime, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
+    let date2 = /* @__PURE__ */ new Date();
+    let year = (0, $3b62074eb05584b2$export$c36e0ecb2d4fa69d)(dateTime.era, dateTime.year);
+    date2.setFullYear(year, dateTime.month - 1, dateTime.day);
+    date2.setHours(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+    return date2.getTime();
+  }
+  let ms = $11d87f3f76e88657$export$bd4fb2bc8bb06fb(dateTime);
+  let offsetBefore = $11d87f3f76e88657$export$59c99f3515d3493f(ms - $11d87f3f76e88657$var$DAYMILLIS, timeZone);
+  let offsetAfter = $11d87f3f76e88657$export$59c99f3515d3493f(ms + $11d87f3f76e88657$var$DAYMILLIS, timeZone);
+  let valid = $11d87f3f76e88657$var$getValidWallTimes(dateTime, timeZone, ms - offsetBefore, ms - offsetAfter);
+  if (valid.length === 1) return valid[0];
+  if (valid.length > 1) switch (disambiguation) {
+    // 'compatible' means 'earlier' for "fall back" transitions
+    case "compatible":
+    case "earlier":
+      return valid[0];
+    case "later":
+      return valid[valid.length - 1];
+    case "reject":
+      throw new RangeError("Multiple possible absolute times found");
+  }
+  switch (disambiguation) {
+    case "earlier":
+      return Math.min(ms - offsetBefore, ms - offsetAfter);
+    // 'compatible' means 'later' for "spring forward" transitions
+    case "compatible":
+    case "later":
+      return Math.max(ms - offsetBefore, ms - offsetAfter);
+    case "reject":
+      throw new RangeError("No such absolute time found");
+  }
+}
+function $11d87f3f76e88657$export$e67a095c620b86fe(dateTime, timeZone, disambiguation = "compatible") {
+  return new Date($11d87f3f76e88657$export$5107c82f94518f5c(dateTime, timeZone, disambiguation));
+}
+function $11d87f3f76e88657$export$b21e0b124e224484(date, time) {
+  let hour = 0, minute = 0, second = 0, millisecond = 0;
+  if ("timeZone" in date) ({ hour, minute, second, millisecond } = date);
+  else if ("hour" in date && !time) return date;
+  if (time) ({ hour, minute, second, millisecond } = time);
+  return new (0, $35ea8db9cb2ccb90$export$ca871e8dbb80966f)(date.calendar, date.era, date.year, date.month, date.day, hour, minute, second, millisecond);
+}
+function $11d87f3f76e88657$export$b4a036af3fc0b032(date, calendar) {
+  if ((0, $14e0f24ef4ac5c92$export$dbc69fd56b53d5e)(date.calendar, calendar)) return date;
+  let calendarDate = calendar.fromJulianDay(date.calendar.toJulianDay(date));
+  let copy = date.copy();
+  copy.calendar = calendar;
+  copy.era = calendarDate.era;
+  copy.year = calendarDate.year;
+  copy.month = calendarDate.month;
+  copy.day = calendarDate.day;
+  (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(copy);
+  return copy;
+}
+
+// node_modules/@internationalized/date/dist/manipulation.mjs
+function $735220c2d4774dd3$export$e16d8520af44a096(date, duration) {
+  let mutableDate = date.copy();
+  let days = "hour" in mutableDate ? $735220c2d4774dd3$var$addTimeFields(mutableDate, duration) : 0;
+  $735220c2d4774dd3$var$addYears(mutableDate, duration.years || 0);
+  if (mutableDate.calendar.balanceYearMonth) mutableDate.calendar.balanceYearMonth(mutableDate, date);
+  mutableDate.month += duration.months || 0;
+  $735220c2d4774dd3$var$balanceYearMonth(mutableDate);
+  $735220c2d4774dd3$var$constrainMonthDay(mutableDate);
+  mutableDate.day += (duration.weeks || 0) * 7;
+  mutableDate.day += duration.days || 0;
+  mutableDate.day += days;
+  $735220c2d4774dd3$var$balanceDay(mutableDate);
+  if (mutableDate.calendar.balanceDate) mutableDate.calendar.balanceDate(mutableDate);
+  if (mutableDate.year < 1) {
+    mutableDate.year = 1;
+    mutableDate.month = 1;
+    mutableDate.day = 1;
+  }
+  let maxYear = mutableDate.calendar.getYearsInEra(mutableDate);
+  if (mutableDate.year > maxYear) {
+    var _mutableDate_calendar_isInverseEra, _mutableDate_calendar;
+    let isInverseEra = (_mutableDate_calendar_isInverseEra = (_mutableDate_calendar = mutableDate.calendar).isInverseEra) === null || _mutableDate_calendar_isInverseEra === void 0 ? void 0 : _mutableDate_calendar_isInverseEra.call(_mutableDate_calendar, mutableDate);
+    mutableDate.year = maxYear;
+    mutableDate.month = isInverseEra ? 1 : mutableDate.calendar.getMonthsInYear(mutableDate);
+    mutableDate.day = isInverseEra ? 1 : mutableDate.calendar.getDaysInMonth(mutableDate);
+  }
+  if (mutableDate.month < 1) {
+    mutableDate.month = 1;
+    mutableDate.day = 1;
+  }
+  let maxMonth = mutableDate.calendar.getMonthsInYear(mutableDate);
+  if (mutableDate.month > maxMonth) {
+    mutableDate.month = maxMonth;
+    mutableDate.day = mutableDate.calendar.getDaysInMonth(mutableDate);
+  }
+  mutableDate.day = Math.max(1, Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day));
+  return mutableDate;
+}
+function $735220c2d4774dd3$var$addYears(date, years) {
+  var _date_calendar_isInverseEra, _date_calendar;
+  if ((_date_calendar_isInverseEra = (_date_calendar = date.calendar).isInverseEra) === null || _date_calendar_isInverseEra === void 0 ? void 0 : _date_calendar_isInverseEra.call(_date_calendar, date)) years = -years;
+  date.year += years;
+}
+function $735220c2d4774dd3$var$balanceYearMonth(date) {
+  while (date.month < 1) {
+    $735220c2d4774dd3$var$addYears(date, -1);
+    date.month += date.calendar.getMonthsInYear(date);
+  }
+  let monthsInYear = 0;
+  while (date.month > (monthsInYear = date.calendar.getMonthsInYear(date))) {
+    date.month -= monthsInYear;
+    $735220c2d4774dd3$var$addYears(date, 1);
+  }
+}
+function $735220c2d4774dd3$var$balanceDay(date) {
+  while (date.day < 1) {
+    date.month--;
+    $735220c2d4774dd3$var$balanceYearMonth(date);
+    date.day += date.calendar.getDaysInMonth(date);
+  }
+  while (date.day > date.calendar.getDaysInMonth(date)) {
+    date.day -= date.calendar.getDaysInMonth(date);
+    date.month++;
+    $735220c2d4774dd3$var$balanceYearMonth(date);
+  }
+}
+function $735220c2d4774dd3$var$constrainMonthDay(date) {
+  date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
+  date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+}
+function $735220c2d4774dd3$export$c4e2ecac49351ef2(date) {
+  if (date.calendar.constrainDate) date.calendar.constrainDate(date);
+  date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
+  $735220c2d4774dd3$var$constrainMonthDay(date);
+}
+function $735220c2d4774dd3$export$3e2544e88a25bff8(duration) {
+  let inverseDuration = {};
+  for (let key in duration) if (typeof duration[key] === "number") inverseDuration[key] = -duration[key];
+  return inverseDuration;
+}
+function $735220c2d4774dd3$export$4e2d2ead65e5f7e3(date, duration) {
+  return $735220c2d4774dd3$export$e16d8520af44a096(date, $735220c2d4774dd3$export$3e2544e88a25bff8(duration));
+}
+function $735220c2d4774dd3$export$adaa4cf7ef1b65be(date, fields) {
+  let mutableDate = date.copy();
+  if (fields.era != null) mutableDate.era = fields.era;
+  if (fields.year != null) mutableDate.year = fields.year;
+  if (fields.month != null) mutableDate.month = fields.month;
+  if (fields.day != null) mutableDate.day = fields.day;
+  $735220c2d4774dd3$export$c4e2ecac49351ef2(mutableDate);
+  return mutableDate;
+}
+function $735220c2d4774dd3$export$e5d5e1c1822b6e56(value, fields) {
+  let mutableValue = value.copy();
+  if (fields.hour != null) mutableValue.hour = fields.hour;
+  if (fields.minute != null) mutableValue.minute = fields.minute;
+  if (fields.second != null) mutableValue.second = fields.second;
+  if (fields.millisecond != null) mutableValue.millisecond = fields.millisecond;
+  $735220c2d4774dd3$export$7555de1e070510cb(mutableValue);
+  return mutableValue;
+}
+function $735220c2d4774dd3$var$balanceTime(time) {
+  time.second += Math.floor(time.millisecond / 1e3);
+  time.millisecond = $735220c2d4774dd3$var$nonNegativeMod(time.millisecond, 1e3);
+  time.minute += Math.floor(time.second / 60);
+  time.second = $735220c2d4774dd3$var$nonNegativeMod(time.second, 60);
+  time.hour += Math.floor(time.minute / 60);
+  time.minute = $735220c2d4774dd3$var$nonNegativeMod(time.minute, 60);
+  let days = Math.floor(time.hour / 24);
+  time.hour = $735220c2d4774dd3$var$nonNegativeMod(time.hour, 24);
+  return days;
+}
+function $735220c2d4774dd3$export$7555de1e070510cb(time) {
+  time.millisecond = Math.max(0, Math.min(time.millisecond, 1e3));
+  time.second = Math.max(0, Math.min(time.second, 59));
+  time.minute = Math.max(0, Math.min(time.minute, 59));
+  time.hour = Math.max(0, Math.min(time.hour, 23));
+}
+function $735220c2d4774dd3$var$nonNegativeMod(a, b) {
+  let result = a % b;
+  if (result < 0) result += b;
+  return result;
+}
+function $735220c2d4774dd3$var$addTimeFields(time, duration) {
+  time.hour += duration.hours || 0;
+  time.minute += duration.minutes || 0;
+  time.second += duration.seconds || 0;
+  time.millisecond += duration.milliseconds || 0;
+  return $735220c2d4774dd3$var$balanceTime(time);
+}
+function $735220c2d4774dd3$export$d52ced6badfb9a4c(value, field2, amount, options) {
+  let mutable = value.copy();
+  switch (field2) {
+    case "era": {
+      let eras = value.calendar.getEras();
+      let eraIndex = eras.indexOf(value.era);
+      if (eraIndex < 0) throw new Error("Invalid era: " + value.era);
+      eraIndex = $735220c2d4774dd3$var$cycleValue(eraIndex, amount, 0, eras.length - 1, options === null || options === void 0 ? void 0 : options.round);
+      mutable.era = eras[eraIndex];
+      $735220c2d4774dd3$export$c4e2ecac49351ef2(mutable);
+      break;
+    }
+    case "year":
+      var _mutable_calendar_isInverseEra, _mutable_calendar;
+      if ((_mutable_calendar_isInverseEra = (_mutable_calendar = mutable.calendar).isInverseEra) === null || _mutable_calendar_isInverseEra === void 0 ? void 0 : _mutable_calendar_isInverseEra.call(_mutable_calendar, mutable)) amount = -amount;
+      mutable.year = $735220c2d4774dd3$var$cycleValue(value.year, amount, -Infinity, 9999, options === null || options === void 0 ? void 0 : options.round);
+      if (mutable.year === -Infinity) mutable.year = 1;
+      if (mutable.calendar.balanceYearMonth) mutable.calendar.balanceYearMonth(mutable, value);
+      break;
+    case "month":
+      mutable.month = $735220c2d4774dd3$var$cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options === null || options === void 0 ? void 0 : options.round);
+      break;
+    case "day":
+      mutable.day = $735220c2d4774dd3$var$cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options === null || options === void 0 ? void 0 : options.round);
+      break;
+    default:
+      throw new Error("Unsupported field " + field2);
+  }
+  if (value.calendar.balanceDate) value.calendar.balanceDate(mutable);
+  $735220c2d4774dd3$export$c4e2ecac49351ef2(mutable);
+  return mutable;
+}
+function $735220c2d4774dd3$export$dd02b3e0007dfe28(value, field2, amount, options) {
+  let mutable = value.copy();
+  switch (field2) {
+    case "hour": {
+      let hours = value.hour;
+      let min = 0;
+      let max = 23;
+      if ((options === null || options === void 0 ? void 0 : options.hourCycle) === 12) {
+        let isPM = hours >= 12;
+        min = isPM ? 12 : 0;
+        max = isPM ? 23 : 11;
+      }
+      mutable.hour = $735220c2d4774dd3$var$cycleValue(hours, amount, min, max, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    }
+    case "minute":
+      mutable.minute = $735220c2d4774dd3$var$cycleValue(value.minute, amount, 0, 59, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    case "second":
+      mutable.second = $735220c2d4774dd3$var$cycleValue(value.second, amount, 0, 59, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    case "millisecond":
+      mutable.millisecond = $735220c2d4774dd3$var$cycleValue(value.millisecond, amount, 0, 999, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    default:
+      throw new Error("Unsupported field " + field2);
+  }
+  return mutable;
+}
+function $735220c2d4774dd3$var$cycleValue(value, amount, min, max, round = false) {
+  if (round) {
+    value += Math.sign(amount);
+    if (value < min) value = max;
+    let div = Math.abs(amount);
+    if (amount > 0) value = Math.ceil(value / div) * div;
+    else value = Math.floor(value / div) * div;
+    if (value > max) value = min;
+  } else {
+    value += amount;
+    if (value < min) value = max - (min - value - 1);
+    else if (value > max) value = min + (value - max - 1);
+  }
+  return value;
+}
+
+// node_modules/@internationalized/date/dist/string.mjs
+var $fae977aafc393c5c$var$requiredDurationTimeGroups = [
+  "hours",
+  "minutes",
+  "seconds"
+];
+var $fae977aafc393c5c$var$requiredDurationGroups = [
+  "years",
+  "months",
+  "weeks",
+  "days",
+  ...$fae977aafc393c5c$var$requiredDurationTimeGroups
+];
+function $fae977aafc393c5c$export$f59dee82248f5ad4(time) {
+  return `${String(time.hour).padStart(2, "0")}:${String(time.minute).padStart(2, "0")}:${String(time.second).padStart(2, "0")}${time.millisecond ? String(time.millisecond / 1e3).slice(1) : ""}`;
+}
+function $fae977aafc393c5c$export$60dfd74aa96791bd(date) {
+  let gregorianDate = (0, $11d87f3f76e88657$export$b4a036af3fc0b032)(date, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
+  let year;
+  if (gregorianDate.era === "BC") year = gregorianDate.year === 1 ? "0000" : "-" + String(Math.abs(1 - gregorianDate.year)).padStart(6, "00");
+  else year = String(gregorianDate.year).padStart(4, "0");
+  return `${year}-${String(gregorianDate.month).padStart(2, "0")}-${String(gregorianDate.day).padStart(2, "0")}`;
+}
+function $fae977aafc393c5c$export$4223de14708adc63(date) {
+  return `${$fae977aafc393c5c$export$60dfd74aa96791bd(date)}T${$fae977aafc393c5c$export$f59dee82248f5ad4(date)}`;
+}
+
+// node_modules/@swc/helpers/esm/_check_private_redeclaration.js
+function _check_private_redeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+
+// node_modules/@swc/helpers/esm/_class_private_field_init.js
+function _class_private_field_init(obj, privateMap, value) {
+  _check_private_redeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+
+// node_modules/@internationalized/date/dist/CalendarDate.mjs
+function $35ea8db9cb2ccb90$var$shiftArgs(args) {
+  let calendar = typeof args[0] === "object" ? args.shift() : new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)();
+  let era;
+  if (typeof args[0] === "string") era = args.shift();
+  else {
+    let eras = calendar.getEras();
+    era = eras[eras.length - 1];
+  }
+  let year = args.shift();
+  let month = args.shift();
+  let day = args.shift();
+  return [
+    calendar,
+    era,
+    year,
+    month,
+    day
+  ];
+}
+var $35ea8db9cb2ccb90$var$_type = /* @__PURE__ */ new WeakMap();
+var $35ea8db9cb2ccb90$export$99faa760c7908e4f = class _$35ea8db9cb2ccb90$export$99faa760c7908e4f {
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) return new _$35ea8db9cb2ccb90$export$99faa760c7908e4f(this.calendar, this.era, this.year, this.month, this.day);
+    else return new _$35ea8db9cb2ccb90$export$99faa760c7908e4f(this.calendar, this.year, this.month, this.day);
+  }
+  /** Returns a new `CalendarDate` with the given duration added to it. */
+  add(duration) {
+    return (0, $735220c2d4774dd3$export$e16d8520af44a096)(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given duration subtracted from it. */
+  subtract(duration) {
+    return (0, $735220c2d4774dd3$export$4e2d2ead65e5f7e3)(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return (0, $735220c2d4774dd3$export$adaa4cf7ef1b65be)(this, fields);
+  }
+  /**
+  * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
+  * When the resulting value reaches the limits of the field, it wraps around.
+  */
+  cycle(field2, amount, options) {
+    return (0, $735220c2d4774dd3$export$d52ced6badfb9a4c)(this, field2, amount, options);
+  }
+  /** Converts the date to a native JavaScript Date object, with the time set to midnight in the given time zone. */
+  toDate(timeZone) {
+    return (0, $11d87f3f76e88657$export$e67a095c620b86fe)(this, timeZone);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return (0, $fae977aafc393c5c$export$60dfd74aa96791bd)(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    return (0, $14e0f24ef4ac5c92$export$68781ddf31c0090f)(this, b);
+  }
+  constructor(...args) {
+    (0, _class_private_field_init)(this, $35ea8db9cb2ccb90$var$_type, {
+      writable: true,
+      value: void 0
+    });
+    let [calendar, era, year, month, day] = $35ea8db9cb2ccb90$var$shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(this);
+  }
+};
+var $35ea8db9cb2ccb90$var$_type2 = /* @__PURE__ */ new WeakMap();
+var $35ea8db9cb2ccb90$export$ca871e8dbb80966f = class _$35ea8db9cb2ccb90$export$ca871e8dbb80966f {
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) return new _$35ea8db9cb2ccb90$export$ca871e8dbb80966f(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+    else return new _$35ea8db9cb2ccb90$export$ca871e8dbb80966f(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+  }
+  /** Returns a new `CalendarDateTime` with the given duration added to it. */
+  add(duration) {
+    return (0, $735220c2d4774dd3$export$e16d8520af44a096)(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
+  subtract(duration) {
+    return (0, $735220c2d4774dd3$export$4e2d2ead65e5f7e3)(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return (0, $735220c2d4774dd3$export$adaa4cf7ef1b65be)((0, $735220c2d4774dd3$export$e5d5e1c1822b6e56)(this, fields), fields);
+  }
+  /**
+  * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
+  * When the resulting value reaches the limits of the field, it wraps around.
+  */
+  cycle(field2, amount, options) {
+    switch (field2) {
+      case "era":
+      case "year":
+      case "month":
+      case "day":
+        return (0, $735220c2d4774dd3$export$d52ced6badfb9a4c)(this, field2, amount, options);
+      default:
+        return (0, $735220c2d4774dd3$export$dd02b3e0007dfe28)(this, field2, amount, options);
+    }
+  }
+  /** Converts the date to a native JavaScript Date object in the given time zone. */
+  toDate(timeZone, disambiguation) {
+    return (0, $11d87f3f76e88657$export$e67a095c620b86fe)(this, timeZone, disambiguation);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return (0, $fae977aafc393c5c$export$4223de14708adc63)(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    let res = (0, $14e0f24ef4ac5c92$export$68781ddf31c0090f)(this, b);
+    if (res === 0) return (0, $14e0f24ef4ac5c92$export$c19a80a9721b80f6)(this, (0, $11d87f3f76e88657$export$b21e0b124e224484)(b));
+    return res;
+  }
+  constructor(...args) {
+    (0, _class_private_field_init)(this, $35ea8db9cb2ccb90$var$_type2, {
+      writable: true,
+      value: void 0
+    });
+    let [calendar, era, year, month, day] = $35ea8db9cb2ccb90$var$shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    this.hour = args.shift() || 0;
+    this.minute = args.shift() || 0;
+    this.second = args.shift() || 0;
+    this.millisecond = args.shift() || 0;
+    (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(this);
+  }
+};
+
+// src/utils/dateCoercion.ts
+function toCalendarDateValue(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "object" && "year" in value && "month" in value && "day" in value && typeof value.year === "number") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return new $35ea8db9cb2ccb90$export$99faa760c7908e4f(
+      value.getFullYear(),
+      value.getMonth() + 1,
+      value.getDate()
+    );
+  }
+  if (typeof value === "string") {
+    const d = new Date(value);
+    if (!isNaN(d.getTime())) {
+      return new $35ea8db9cb2ccb90$export$99faa760c7908e4f(d.getFullYear(), d.getMonth() + 1, d.getDate());
+    }
+  }
+  return null;
+}
+
+// src/fields/DateField.tsx
 function CoercedDateInput(props) {
   const { dateProps, description, disabled, errorMessage, field: field2, label } = props;
   const defaults = useHeroHookFormDefaults();
+  const dateValue = toCalendarDateValue(field2.value);
   return /* @__PURE__ */ React7.createElement(
     DateInput,
     {
@@ -460,7 +1172,7 @@ function CoercedDateInput(props) {
       isInvalid: Boolean(errorMessage),
       label,
       name: field2.name,
-      value: field2.value ?? null,
+      value: dateValue,
       onBlur: field2.onBlur,
       onChange: field2.onChange
     }
@@ -1371,10 +2083,8 @@ function FormFieldComponent({
       );
     }
   }
-  let shouldRenderConditionalField = true;
   if ("condition" in fieldConfig && fieldConfig.condition && !fieldConfig.condition(watchedValues)) {
     if ("field" in fieldConfig && fieldConfig.field && typeof fieldConfig.field === "object" && "type" in fieldConfig.field && fieldConfig.field.type === "fieldArray" && "alwaysRegistered" in fieldConfig.field && fieldConfig.field.alwaysRegistered === true) {
-      shouldRenderConditionalField = true;
     } else {
       return null;
     }
@@ -1541,8 +2251,7 @@ function FormFieldComponent({
           ...baseProps,
           name: fieldConfig.name,
           control,
-          dateProps: "dateProps" in fieldConfig ? fieldConfig.dateProps : void 0,
-          defaultValue: "defaultValue" in fieldConfig ? fieldConfig.defaultValue : void 0
+          dateProps: "dateProps" in fieldConfig ? fieldConfig.dateProps : void 0
         }
       );
     }
@@ -2272,6 +2981,7 @@ function ServerActionField({
     }
     case "date": {
       const dateConfig = fieldConfig;
+      const dateValue = toCalendarDateValue(value);
       return /* @__PURE__ */ React21.createElement(React21.Fragment, null, /* @__PURE__ */ React21.createElement("input", { type: "hidden", name: fieldName, value: value || "" }), /* @__PURE__ */ React21.createElement(
         DateInput,
         {
@@ -2282,7 +2992,7 @@ function ServerActionField({
           isDisabled: baseProps.isDisabled,
           isInvalid: Boolean(errorMessage),
           errorMessage,
-          value: value ? value : null,
+          value: dateValue,
           onChange: (date) => {
             const dateString = date ? `${date.year}-${String(date.month).padStart(2, "0")}-${String(date.day).padStart(2, "0")}` : "";
             setValue(dateString);
@@ -2675,11 +3385,80 @@ function createZodResolver(schema) {
     }
   };
 }
+function toCalendarDate(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "object" && "year" in value && "month" in value && "day" in value && typeof value.year === "number") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return new $35ea8db9cb2ccb90$export$99faa760c7908e4f(
+      value.getFullYear(),
+      value.getMonth() + 1,
+      value.getDate()
+    );
+  }
+  if (typeof value === "string") {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return new $35ea8db9cb2ccb90$export$99faa760c7908e4f(
+        date.getFullYear(),
+        date.getMonth() + 1,
+        date.getDate()
+      );
+    }
+  }
+  return value;
+}
+function defaultValuesFromFields(fields) {
+  const out = {};
+  const dateFieldNames = /* @__PURE__ */ new Set();
+  for (const field2 of fields) {
+    if ("name" in field2 && field2.name !== void 0 && field2.type === "date") {
+      dateFieldNames.add(String(field2.name));
+    }
+  }
+  for (const field2 of fields) {
+    if ("name" in field2 && field2.name !== void 0 && "defaultValue" in field2 && field2.defaultValue !== void 0) {
+      const fieldName = String(field2.name);
+      let value = field2.defaultValue;
+      if (dateFieldNames.has(fieldName)) {
+        value = toCalendarDate(value);
+      }
+      out[fieldName] = value;
+    }
+  }
+  return out;
+}
 function useZodForm(config) {
-  if (!config.resolver && config.schema) {
-    config.resolver = createZodResolver(config.schema);
+  const resolver = config.resolver ?? (config.schema ? createZodResolver(config.schema) : void 0);
+  const fieldDefaults = defaultValuesFromFields(
+    config.fields
+  );
+  const hasFieldDefaults = Object.keys(fieldDefaults).length > 0;
+  const dateFieldNames = /* @__PURE__ */ new Set();
+  for (const field2 of config.fields) {
+    if ("name" in field2 && field2.name !== void 0 && field2.type === "date") {
+      dateFieldNames.add(String(field2.name));
+    }
   }
-  return useForm2(config);
+  const convertedConfigDefaults = config.defaultValues ? Object.entries(config.defaultValues).reduce(
+    (acc, [key, value]) => {
+      acc[key] = dateFieldNames.has(key) ? toCalendarDate(value) : value;
+      return acc;
+    },
+    {}
+  ) : void 0;
+  const mergedDefaultValues = hasFieldDefaults || convertedConfigDefaults ? {
+    ...fieldDefaults,
+    ...convertedConfigDefaults
+  } : convertedConfigDefaults;
+  return useForm2({
+    ...config,
+    ...resolver && { resolver },
+    defaultValues: mergedDefaultValues
+  });
 }
 function createZodFormConfig(schema, fields, defaultValues) {
   return {
@@ -3381,16 +4160,15 @@ var FormFieldHelpers = {
    * // Simple date field
    * FormFieldHelpers.date("birthDate", "Birth Date")
    *
-   * // With full customization
+   * // With DateInput props (set default via config.defaultValues)
    * FormFieldHelpers.date("birthDate", "Birth Date", {
-   *   label: "Select your birth date",
    *   granularity: "day",
-   *   minValue: new CalendarDate(1900, 1, 1)
+   *   minValue: new CalendarDate(1900, 1, 1),
    * })
    * ```
    */
   date: (name, label, dateProps) => ({
-    dateProps,
+    dateProps: Object.keys(dateProps ?? {}).length > 0 ? dateProps : void 0,
     label,
     name,
     type: "date"
@@ -4864,7 +5642,7 @@ function suggestGarbageCollection() {
   if (typeof window !== "undefined" && "gc" in window) {
     try {
       window.gc();
-    } catch (error) {
+    } catch {
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rachelallyson/hero-hook-form",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Typed form helpers that combine React Hook Form and HeroUI components.",
   "author": "Rachel Higley",
   "homepage": "https://rachelallyson.github.io/hero-hook-form/",