@evanschleret/formforgeclient 1.2.4 → 2.0.1

package/dist/runtime/validation/zod.js

@@ -1,95 +1,558 @@
 import { z } from "zod";
-const scalarOptionSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
-function applySharedStringRules(baseSchema, rules) {
+import { createDefaultAddressFields } from "../utils/defaults.js";
+import { resolveTemporalMode } from "../utils/temporal.js";
+function normalizeLocale(locale) {
+  if (locale === void 0 || locale === "") {
+    return "en";
+  }
+  return locale.toLowerCase().startsWith("fr") ? "fr" : "en";
+}
+function resolveLocaleMessages(locale) {
+  const normalizedLocale = normalizeLocale(locale);
+  if (normalizedLocale === "fr") {
+    return {
+      required: "Ce champ est requis",
+      validationFailed: "La valeur ne respecte pas les r\xE8gles de validation",
+      invalidString: "Veuillez saisir un texte valide",
+      invalidNumber: "Veuillez saisir un nombre valide",
+      invalidBoolean: "Veuillez saisir une r\xE9ponse valide",
+      invalidSelection: "Veuillez s\xE9lectionner une option valide",
+      invalidAddress: "Veuillez saisir une adresse valide",
+      invalidFile: "Veuillez s\xE9lectionner un fichier valide",
+      invalidDate: "Veuillez saisir une date valide",
+      invalidTime: "Veuillez saisir une heure valide",
+      invalidEmail: "Veuillez saisir une adresse e-mail valide",
+      minLength: (value) => `Veuillez saisir au moins ${value} caract\xE8res`,
+      maxLength: (value) => `Veuillez saisir au plus ${value} caract\xE8res`,
+      minItems: (value) => `Veuillez s\xE9lectionner au moins ${value} \xE9l\xE9ments`,
+      maxItems: (value) => `Veuillez s\xE9lectionner au plus ${value} \xE9l\xE9ments`,
+      minValue: (value) => `Veuillez saisir une valeur sup\xE9rieure ou \xE9gale \xE0 ${value}`,
+      maxValue: (value) => `Veuillez saisir une valeur inf\xE9rieure ou \xE9gale \xE0 ${value}`,
+      textMin: (label, value) => `${label} doit contenir au moins ${value} caract\xE8res`,
+      textMax: (label, value) => `${label} doit contenir au plus ${value} caract\xE8res`,
+      textRegex: (label) => `${label} doit respecter le format attendu`,
+      textEquals: (label, value) => `${label} doit \xEAtre \xE9gal \xE0 ${value}`,
+      textNotEquals: (label, value) => `${label} ne doit pas \xEAtre \xE9gal \xE0 ${value}`,
+      textContains: (label, value) => `${label} doit contenir ${value}`,
+      textNotContains: (label, value) => `${label} ne doit pas contenir ${value}`,
+      temporalAfter: (label, value) => `${label} doit \xEAtre post\xE9rieur \xE0 ${value}`,
+      temporalBefore: (label, value) => `${label} doit \xEAtre ant\xE9rieur \xE0 ${value}`,
+      temporalBetween: (label, start, end) => `${label} doit \xEAtre compris entre ${start} et ${end}`,
+      temporalNotBetween: (label, start, end) => `${label} ne doit pas \xEAtre compris entre ${start} et ${end}`
+    };
+  }
+  return {
+    required: "This field is required",
+    validationFailed: "The value does not meet the validation rules",
+    invalidString: "Please enter a valid text value",
+    invalidNumber: "Please enter a valid number",
+    invalidBoolean: "Please enter a valid response",
+    invalidSelection: "Please select a valid option",
+    invalidAddress: "Please enter a valid address",
+    invalidFile: "Please select a valid file",
+    invalidDate: "Please enter a valid date",
+    invalidTime: "Please enter a valid time",
+    invalidEmail: "Please enter a valid email address",
+    minLength: (value) => `Please enter at least ${value} characters`,
+    maxLength: (value) => `Please enter no more than ${value} characters`,
+    minItems: (value) => `Please select at least ${value} items`,
+    maxItems: (value) => `Please select no more than ${value} items`,
+    minValue: (value) => `Please enter a value greater than or equal to ${value}`,
+    maxValue: (value) => `Please enter a value less than or equal to ${value}`,
+    textMin: (label, value) => `${label} must contain at least ${value} characters`,
+    textMax: (label, value) => `${label} must contain no more than ${value} characters`,
+    textRegex: (label) => `${label} must match the expected format`,
+    textEquals: (label, value) => `${label} must be equal to ${value}`,
+    textNotEquals: (label, value) => `${label} must not be equal to ${value}`,
+    textContains: (label, value) => `${label} must contain ${value}`,
+    textNotContains: (label, value) => `${label} must not contain ${value}`,
+    temporalAfter: (label, value) => `${label} must be after ${value}`,
+    temporalBefore: (label, value) => `${label} must be before ${value}`,
+    temporalBetween: (label, start, end) => `${label} must be between ${start} and ${end}`,
+    temporalNotBetween: (label, start, end) => `${label} must not be between ${start} and ${end}`
+  };
+}
+function plainTextLabel(value, fallback) {
+  if (typeof value !== "string") {
+    return fallback.replaceAll(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+  }
+  const cleaned = value.replace(/<[^>]*>/g, "").trim();
+  if (cleaned !== "") {
+    return cleaned;
+  }
+  return fallback.replaceAll(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function isMissingValue(value) {
+  return value === void 0 || value === null;
+}
+function typeError(requiredMessage, invalidMessage) {
+  return (issue) => {
+    if (isMissingValue(issue.input)) {
+      return requiredMessage;
+    }
+    return invalidMessage;
+  };
+}
+function buildScalarOptionSchema(messages) {
+  return z.union([z.string(), z.number(), z.boolean(), z.null()], {
+    error: typeError(messages.required, messages.invalidSelection)
+  });
+}
+function resolveLocaleErrorMap(locale) {
+  const normalizedLocale = normalizeLocale(locale);
+  if (normalizedLocale === "fr") {
+    return z.locales.fr().localeError;
+  }
+  return z.locales.en().localeError;
+}
+function isBlankAddressValue(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every((item) => {
+    if (item === void 0 || item === null) {
+      return true;
+    }
+    if (typeof item === "string") {
+      return item.trim() === "";
+    }
+    return false;
+  });
+}
+function addressFieldDefinitions(field, locale) {
+  if (!Array.isArray(field.address_fields) || field.address_fields.length === 0) {
+    return createDefaultAddressFields(locale);
+  }
+  const defaults = createDefaultAddressFields(locale);
+  return field.address_fields.map((candidate, index) => ({
+    key: candidate.key,
+    label: typeof candidate.label === "string" && candidate.label !== "" ? candidate.label : defaults[index]?.label ?? `Field ${index + 1}`,
+    visible: candidate.visible !== false,
+    required: candidate.required === true
+  }));
+}
+function fieldValidationConfig(field) {
+  if (typeof field.meta !== "object" || field.meta === null || Array.isArray(field.meta)) {
+    return null;
+  }
+  const validation = field.meta.validation;
+  if (validation === void 0 || validation === null || Array.isArray(validation) || typeof validation !== "object") {
+    return null;
+  }
+  const candidate = validation;
+  if (candidate.match !== "all" && candidate.match !== "any" || !Array.isArray(candidate.rules)) {
+    return null;
+  }
+  return {
+    match: candidate.match,
+    rules: candidate.rules
+  };
+}
+function isValidationRuleNumeric(rule) {
+  return rule.operator === "min" || rule.operator === "max";
+}
+function validationFieldLabel(field) {
+  return plainTextLabel(field.label, field.name);
+}
+function validationAddressFieldLabel(field, target, locale) {
+  const addressField = addressFieldDefinitions(field, locale).find((candidate) => candidate.key === target);
+  if (addressField === void 0) {
+    return target;
+  }
+  return plainTextLabel(addressField.label, target);
+}
+function validationRuleMessage(subjectLabel, rule, messages) {
+  if (rule.operator === "min") {
+    const value = Number.parseFloat(String(rule.value ?? 0));
+    return messages.textMin(subjectLabel, Number.isNaN(value) ? 0 : value);
+  }
+  if (rule.operator === "max") {
+    const value = Number.parseFloat(String(rule.value ?? 0));
+    return messages.textMax(subjectLabel, Number.isNaN(value) ? 0 : value);
+  }
+  if (rule.operator === "regex") {
+    return messages.textRegex(subjectLabel);
+  }
+  if (rule.operator === "eq") {
+    return messages.textEquals(subjectLabel, String(rule.value ?? ""));
+  }
+  if (rule.operator === "neq") {
+    return messages.textNotEquals(subjectLabel, String(rule.value ?? ""));
+  }
+  if (rule.operator === "contains") {
+    return messages.textContains(subjectLabel, String(rule.value ?? ""));
+  }
+  if (rule.operator === "not_contains") {
+    return messages.textNotContains(subjectLabel, String(rule.value ?? ""));
+  }
+  if (rule.operator === "after") {
+    return messages.temporalAfter(subjectLabel, String(rule.value ?? ""));
+  }
+  if (rule.operator === "before") {
+    return messages.temporalBefore(subjectLabel, String(rule.value ?? ""));
+  }
+  if (rule.operator === "between" || rule.operator === "not_between") {
+    const rangeValue = temporalValidationRangeValue(rule.value);
+    const start = rangeValue?.start ?? "";
+    const end = rangeValue?.end ?? "";
+    if (rule.operator === "between") {
+      return messages.temporalBetween(subjectLabel, start, end);
+    }
+    return messages.temporalNotBetween(subjectLabel, start, end);
+  }
+  return messages.validationFailed;
+}
+function parseValidationRuleValue(rule) {
+  if (isValidationRuleNumeric(rule)) {
+    const parsed = typeof rule.value === "number" ? rule.value : Number.parseFloat(String(rule.value));
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  return typeof rule.value === "string" ? rule.value : String(rule.value ?? "");
+}
+function evaluateTextValidationRule(value, rule) {
+  const ruleValue = parseValidationRuleValue(rule);
+  if (rule.operator === "min") {
+    return value.length >= Number(ruleValue);
+  }
+  if (rule.operator === "max") {
+    return value.length <= Number(ruleValue);
+  }
+  if (rule.operator === "eq") {
+    return value === String(ruleValue);
+  }
+  if (rule.operator === "neq") {
+    return value !== String(ruleValue);
+  }
+  if (rule.operator === "contains") {
+    return value.includes(String(ruleValue));
+  }
+  if (rule.operator === "not_contains") {
+    return !value.includes(String(ruleValue));
+  }
+  if (rule.operator === "regex") {
+    try {
+      return new RegExp(String(ruleValue)).test(value);
+    } catch {
+      return false;
+    }
+  }
+  return null;
+}
+function parseTemporalComparable(value, temporalMode) {
+  if (temporalMode === "time") {
+    const match2 = value.trim().match(/^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/);
+    if (match2 === null) {
+      return null;
+    }
+    const hours = Number.parseInt(match2[1] ?? "0", 10);
+    const minutes = Number.parseInt(match2[2] ?? "0", 10);
+    const seconds = Number.parseInt(match2[3] ?? "0", 10);
+    const milliseconds = Number.parseInt((match2[4] ?? "0").padEnd(3, "0"), 10);
+    return ((hours * 60 + minutes) * 60 + seconds) * 1e3 + milliseconds;
+  }
+  const match = value.trim().match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (match === null) {
+    return null;
+  }
+  const year = Number.parseInt(match[1] ?? "0", 10);
+  const month = Number.parseInt(match[2] ?? "0", 10);
+  const day = Number.parseInt(match[3] ?? "0", 10);
+  return Date.UTC(year, month - 1, day);
+}
+function temporalValidationRangeValue(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  const candidate = value;
+  return {
+    start: typeof candidate.start === "string" ? candidate.start : null,
+    end: typeof candidate.end === "string" ? candidate.end : null
+  };
+}
+function evaluateTemporalValidationRule(value, rule, temporalMode) {
+  const actualComparable = parseTemporalComparable(value, temporalMode);
+  const operator = rule.operator;
+  if (operator === "between" || operator === "not_between") {
+    const rangeValue = temporalValidationRangeValue(rule.value);
+    if (rangeValue === null) {
+      return null;
+    }
+    const startComparable = rangeValue.start === null ? null : parseTemporalComparable(rangeValue.start, temporalMode);
+    const endComparable = rangeValue.end === null ? null : parseTemporalComparable(rangeValue.end, temporalMode);
+    if (actualComparable === null || startComparable === null || endComparable === null) {
+      return null;
+    }
+    const isBetween = actualComparable >= startComparable && actualComparable <= endComparable;
+    return operator === "between" ? isBetween : !isBetween;
+  }
+  const ruleComparable = parseTemporalComparable(typeof rule.value === "string" ? rule.value : String(rule.value ?? ""), temporalMode);
+  if (actualComparable === null || ruleComparable === null) {
+    return null;
+  }
+  if (operator === "after") {
+    return actualComparable > ruleComparable;
+  }
+  if (operator === "before") {
+    return actualComparable < ruleComparable;
+  }
+  if (operator === "min") {
+    return actualComparable >= ruleComparable;
+  }
+  if (operator === "max") {
+    return actualComparable <= ruleComparable;
+  }
+  if (operator === "eq") {
+    return actualComparable === ruleComparable;
+  }
+  if (operator === "neq") {
+    return actualComparable !== ruleComparable;
+  }
+  return null;
+}
+function applyTextValidationRules(baseSchema, field, messages) {
+  const config = fieldValidationConfig(field);
+  if (config === null || config.rules.length === 0) {
+    return baseSchema;
+  }
+  return baseSchema.superRefine((value, context) => {
+    const results = config.rules.map((rule) => ({
+      rule,
+      result: evaluateTextValidationRule(value, rule)
+    }));
+    const validResults = results.filter((candidate) => candidate.result !== null);
+    if (validResults.length === 0) {
+      return;
+    }
+    if (config.match === "any") {
+      if (validResults.some((candidate) => candidate.result === true)) {
+        return;
+      }
+      for (const candidate of validResults) {
+        if (candidate.result === false) {
+          context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: validationRuleMessage(validationFieldLabel(field), candidate.rule, messages)
+          });
+        }
+      }
+      return;
+    }
+    for (const candidate of validResults) {
+      if (candidate.result === false) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: validationRuleMessage(validationFieldLabel(field), candidate.rule, messages)
+        });
+      }
+    }
+  });
+}
+function applyAddressValidationRules(baseSchema, field, messages, locale) {
+  const config = fieldValidationConfig(field);
+  if (config === null || config.rules.length === 0) {
+    return baseSchema;
+  }
+  return baseSchema.superRefine((value, context) => {
+    const results = config.rules.map((rule) => {
+      const target = typeof rule.target === "string" ? rule.target : "";
+      if (target === "") {
+        return {
+          rule,
+          result: null
+        };
+      }
+      const actualValue = value[target];
+      if (typeof actualValue !== "string") {
+        return {
+          rule,
+          result: false
+        };
+      }
+      return {
+        rule,
+        result: evaluateTextValidationRule(actualValue, rule)
+      };
+    });
+    const validResults = results.filter((candidate) => candidate.result !== null);
+    if (validResults.length === 0) {
+      return;
+    }
+    if (config.match === "any") {
+      if (validResults.some((candidate) => candidate.result === true)) {
+        return;
+      }
+    }
+    for (const candidate of validResults) {
+      if (candidate.result === false) {
+        const target = typeof candidate.rule.target === "string" ? candidate.rule.target : "";
+        const message = validationRuleMessage(
+          validationAddressFieldLabel(field, target, locale),
+          candidate.rule,
+          messages
+        );
+        if (target === "") {
+          context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message
+          });
+          continue;
+        }
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [target],
+          message
+        });
+      }
+    }
+  });
+}
+function applySharedStringRules(baseSchema, rules, messages) {
   let schema = baseSchema;
   for (const rawRule of rules) {
     const [ruleName, ruleArgument] = rawRule.split(":");
     if (ruleName === "email") {
-      schema = schema.email();
+      schema = schema.email({
+        error: messages.invalidEmail
+      });
       continue;
     }
     if (ruleName === "min" && ruleArgument !== void 0) {
       const parsedMin = Number.parseInt(ruleArgument, 10);
       if (!Number.isNaN(parsedMin)) {
-        schema = schema.min(parsedMin);
+        schema = schema.min(parsedMin, {
+          error: messages.minLength(parsedMin)
+        });
       }
       continue;
     }
     if (ruleName === "max" && ruleArgument !== void 0) {
       const parsedMax = Number.parseInt(ruleArgument, 10);
       if (!Number.isNaN(parsedMax)) {
-        schema = schema.max(parsedMax);
+        schema = schema.max(parsedMax, {
+          error: messages.maxLength(parsedMax)
+        });
       }
       continue;
     }
   }
   return schema;
 }
-function applyArrayRules(baseSchema, rules) {
+function applyArrayRules(baseSchema, rules, messages) {
   let schema = baseSchema;
   for (const rawRule of rules) {
     const [ruleName, ruleArgument] = rawRule.split(":");
     if (ruleName === "min" && ruleArgument !== void 0) {
       const parsedMin = Number.parseInt(ruleArgument, 10);
       if (!Number.isNaN(parsedMin)) {
-        schema = schema.min(parsedMin);
+        schema = schema.min(parsedMin, {
+          error: messages.minItems(parsedMin)
+        });
       }
       continue;
     }
     if (ruleName === "max" && ruleArgument !== void 0) {
       const parsedMax = Number.parseInt(ruleArgument, 10);
       if (!Number.isNaN(parsedMax)) {
-        schema = schema.max(parsedMax);
+        schema = schema.max(parsedMax, {
+          error: messages.maxItems(parsedMax)
+        });
       }
       continue;
     }
   }
   return schema;
 }
-function applyNumberRules(baseSchema, rules) {
+function applyNumberRules(baseSchema, rules, messages) {
   let schema = baseSchema;
   for (const rawRule of rules) {
     const [ruleName, ruleArgument] = rawRule.split(":");
     if (ruleName === "min" && ruleArgument !== void 0) {
       const parsedMin = Number.parseFloat(ruleArgument);
       if (!Number.isNaN(parsedMin)) {
-        schema = schema.min(parsedMin);
+        schema = schema.min(parsedMin, {
+          error: messages.minValue(parsedMin)
+        });
       }
       continue;
     }
     if (ruleName === "max" && ruleArgument !== void 0) {
       const parsedMax = Number.parseFloat(ruleArgument);
       if (!Number.isNaN(parsedMax)) {
-        schema = schema.max(parsedMax);
+        schema = schema.max(parsedMax, {
+          error: messages.maxValue(parsedMax)
+        });
       }
       continue;
     }
   }
   return schema;
 }
-function buildFieldBaseSchema(field) {
+function buildFieldBaseSchema(field, messages, locale) {
   if (field.type === "text" || field.type === "textarea" || field.type === "email") {
-    return applySharedStringRules(z.string(), field.rules);
+    const baseSchema = applySharedStringRules(z.string({
+      error: typeError(messages.required, messages.invalidString)
+    }), field.rules, messages);
+    if (field.type === "email") {
+      return applyTextValidationRules(baseSchema.email({
+        error: messages.invalidEmail
+      }), field, messages);
+    }
+    return applyTextValidationRules(baseSchema, field, messages);
   }
   if (field.type === "number") {
-    return applyNumberRules(z.number(), field.rules);
+    return applyNumberRules(z.number({
+      error: typeError(messages.required, messages.invalidNumber)
+    }), field.rules, messages);
   }
   if (field.type === "select" || field.type === "select_menu" || field.type === "radio") {
-    return scalarOptionSchema;
+    return buildScalarOptionSchema(messages);
   }
-  if (field.type === "checkbox" || field.type === "switch") {
-    return z.boolean();
+  if (field.type === "checkbox" || field.type === "consent" || field.type === "switch") {
+    return z.boolean({
+      error: typeError(messages.required, messages.invalidBoolean)
+    });
   }
   if (field.type === "checkbox_group") {
-    return applyArrayRules(z.array(scalarOptionSchema), field.rules);
+    return applyArrayRules(z.array(buildScalarOptionSchema(messages), {
+      error: typeError(messages.required, messages.invalidSelection)
+    }), field.rules, messages);
   }
-  if (field.type === "date" || field.type === "time" || field.type === "datetime") {
-    return applySharedStringRules(z.string(), field.rules);
-  }
-  if (field.type === "date_range" || field.type === "datetime_range") {
-    return z.object({
-      start: z.string().nullable(),
-      end: z.string().nullable()
+  if (field.type === "temporal" || field.type === "date" || field.type === "time") {
+    const temporalMode = resolveTemporalMode(field);
+    const invalidMessage = temporalMode === "time" ? messages.invalidTime : messages.invalidDate;
+    const baseSchema = applySharedStringRules(z.string({
+      error: typeError(messages.required, invalidMessage)
+    }), field.rules, messages);
+    return baseSchema.refine((value) => {
+      return parseTemporalComparable(value, temporalMode) !== null;
+    }, {
+      message: invalidMessage
+    }).superRefine((value, context) => {
+      const config = fieldValidationConfig(field);
+      if (config === null || config.rules.length === 0) {
+        return;
+      }
+      const results = config.rules.map((rule) => ({
+        rule,
+        result: evaluateTemporalValidationRule(value, rule, temporalMode)
+      }));
+      const validResults = results.filter((candidate) => candidate.result !== null);
+      if (validResults.length === 0) {
+        return;
+      }
+      if (config.match === "any") {
+        if (validResults.some((candidate) => candidate.result === true)) {
+          return;
+        }
+      }
+      for (const candidate of validResults) {
+        if (candidate.result === false) {
+          context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: validationRuleMessage(validationFieldLabel(field), candidate.rule, messages)
+          });
+        }
+      }
     });
   }
   if (field.type === "file") {
@@ -98,15 +561,51 @@ function buildFieldBaseSchema(field) {
         return false;
       }
       return value instanceof File;
+    }, {
+      error: typeError(messages.required, messages.invalidFile)
     });
     if (field.multiple === true) {
-      return z.array(fileSchema);
+      return z.array(fileSchema, {
+        error: typeError(messages.required, messages.invalidFile)
+      });
     }
     return fileSchema;
   }
-  return scalarOptionSchema;
+  if (field.type === "address") {
+    const shape = {};
+    for (const addressField of addressFieldDefinitions(field, locale)) {
+      if (!addressField.visible) {
+        continue;
+      }
+      shape[addressField.key] = z.union([z.string(), z.null()]).optional();
+    }
+    return applyAddressValidationRules(z.object(shape, {
+      error: typeError(messages.required, messages.invalidAddress)
+    }).superRefine((value, context) => {
+      const topLevelRequired = field.required === true;
+      for (const addressField of addressFieldDefinitions(field, locale)) {
+        if (!addressField.visible) {
+          continue;
+        }
+        const effectiveRequired = topLevelRequired || addressField.required;
+        if (!effectiveRequired) {
+          continue;
+        }
+        const fieldValue = value[addressField.key];
+        const isEmpty = fieldValue === void 0 || fieldValue === null || typeof fieldValue === "string" && fieldValue.trim() === "";
+        if (isEmpty) {
+          context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [addressField.key],
+            message: messages.required
+          });
+        }
+      }
+    }), field, messages, locale);
+  }
+  return buildScalarOptionSchema(messages);
 }
-function applyRequiredAndNullable(schema, field) {
+function applyRequiredAndNullable(schema, field, messages, locale) {
   const optionalSchema = schema.optional();
   if (field.required === false) {
     return z.preprocess((value) => {
@@ -116,25 +615,38 @@ function applyRequiredAndNullable(schema, field) {
       if (typeof value === "string" && value.trim() === "") {
         return void 0;
       }
-      if ((field.type === "date_range" || field.type === "datetime_range") && typeof value === "object" && value !== null) {
-        const rangeValue = value;
-        const isStartEmpty = rangeValue.start === void 0 || rangeValue.start === null || rangeValue.start === "";
-        const isEndEmpty = rangeValue.end === void 0 || rangeValue.end === null || rangeValue.end === "";
-        if (isStartEmpty && isEndEmpty) {
-          return void 0;
-        }
-      }
       if (field.type === "checkbox_group" && Array.isArray(value) && value.length === 0) {
         return void 0;
       }
+      if (field.type === "address" && isBlankAddressValue(value)) {
+        const addressFields = addressFieldDefinitions(field, locale);
+        const hasRequiredAddressField = addressFields.some((candidate) => candidate.visible !== false && (field.required || candidate.required));
+        if (hasRequiredAddressField) {
+          return value;
+        }
+        return void 0;
+      }
       return value;
     }, optionalSchema);
   }
-  if (field.type === "text" || field.type === "textarea" || field.type === "email" || field.type === "date" || field.type === "time" || field.type === "datetime") {
+  if (field.type === "number") {
+    return z.preprocess((value) => {
+      if (typeof value === "string" && value.trim() === "") {
+        return void 0;
+      }
+      return value;
+    }, schema);
+  }
+  if (field.type === "text" || field.type === "textarea" || field.type === "email") {
     return schema.refine((value) => {
       return typeof value === "string" && value.trim() !== "";
     }, {
-      message: "Required"
+      message: messages.required
+    });
+  }
+  if (field.type === "consent") {
+    return schema.refine((value) => value === true, {
+      message: messages.required
     });
   }
   if (field.type === "select" || field.type === "select_menu" || field.type === "radio") {
@@ -147,36 +659,31 @@ function applyRequiredAndNullable(schema, field) {
       }
       return true;
     }, {
-      message: "Required"
+      message: messages.required
     });
   }
   if (field.type === "checkbox_group") {
     return schema.refine((value) => {
       return Array.isArray(value) && value.length > 0;
     }, {
-      message: "Required"
+      message: messages.required
     });
   }
-  if (field.type === "date_range" || field.type === "datetime_range") {
+  if (field.type === "date" || field.type === "time" || field.type === "temporal") {
     return schema.refine((value) => {
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return false;
-      }
-      const rangeValue = value;
-      const isStartValid = typeof rangeValue.start === "string" && rangeValue.start !== "";
-      const isEndValid = typeof rangeValue.end === "string" && rangeValue.end !== "";
-      return isStartValid && isEndValid;
+      return typeof value === "string" && value.trim() !== "";
     }, {
-      message: "Required"
+      message: messages.required
     });
   }
   return schema;
 }
-export function createFormForgeZodSchema(form) {
+export function createFormForgeZodSchema(form, options = {}) {
+  const messages = resolveLocaleMessages(options.locale);
   const shape = {};
   for (const field of form.fields) {
-    const baseSchema = buildFieldBaseSchema(field);
-    shape[field.name] = applyRequiredAndNullable(baseSchema, field);
+    const baseSchema = buildFieldBaseSchema(field, messages, options.locale);
+    shape[field.name] = applyRequiredAndNullable(baseSchema, field, messages, options.locale);
   }
   return z.object(shape);
 }
@@ -194,8 +701,10 @@ export function mapFormForgeZodIssues(error) {
   }
   return fieldErrors;
 }
-export function validateFormForgePayload(schema, payload) {
-  const result = schema.safeParse(payload);
+export function validateFormForgePayload(schema, payload, options = {}) {
+  const result = schema.safeParse(payload, {
+    error: resolveLocaleErrorMap(options.locale)
+  });
   if (result.success) {
     return {};
   }