@maestro-js/form 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,888 @@
+// src/form-root.tsx
+import React2 from "react";
+
+// src/compose-refs.ts
+import * as React from "react";
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ;
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => refs.forEach((ref) => setRef(ref, node));
+}
+
+// src/form-root.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function _HeadlessFormRoot({ id: inputId, children, as, method, ...props }, forwardedRef) {
+  const FormComponent = as ?? "form";
+  const generatedId = React2.useId();
+  const id = inputId ?? generatedId;
+  const formRef = React2.useRef(null);
+  const serverErrors = useServerErrors(id);
+  const { csrfToken } = React2.useContext(GlobalContext);
+  const lastServerErrors = React2.useRef(serverErrors);
+  React2.useEffect(() => {
+    if (formRef?.current && lastServerErrors.current !== serverErrors) {
+      lastServerErrors.current = serverErrors;
+      formRef.current?.checkValidity();
+    }
+  });
+  const isGET = method === "get" || method === "GET" || !method;
+  return /* @__PURE__ */ jsx(formContext.Provider, { value: { id }, children: /* @__PURE__ */ jsxs(
+    FormComponent,
+    {
+      ...props,
+      id,
+      method,
+      ref: composeRefs(formRef, forwardedRef),
+      onSubmit: (e) => {
+        if (isGET) {
+          if (!formRef.current?.checkValidity()) {
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        }
+      },
+      children: [
+        isGET ? null : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("input", { type: "hidden", name: "__formId", value: id }),
+          /* @__PURE__ */ jsx("input", { type: "hidden", name: "__csrfToken", value: csrfToken })
+        ] }),
+        children
+      ]
+    }
+  ) });
+}
+var HeadlessFormRoot = React2.forwardRef(_HeadlessFormRoot);
+var formContext = React2.createContext({ id: "" });
+function GlobalProvider({ useServerErrors: useServerErrors2, children, csrfToken }) {
+  return /* @__PURE__ */ jsx(GlobalContext.Provider, { value: { useServerErrors: useServerErrors2, csrfToken }, children });
+}
+var GlobalContext = React2.createContext({
+  useServerErrors() {
+    throw new Error("'GlobalContext not found. Please wrap your site with GlobalProvider");
+  }
+});
+function useServerErrors(formId) {
+  const { useServerErrors: useServerErrors2 } = React2.useContext(GlobalContext);
+  const context = React2.useContext(formContext);
+  const serverErrors = useServerErrors2(formId ?? context.id);
+  return serverErrors ?? EMPTY_ARR;
+}
+var EMPTY_ARR = [];
+
+// src/hidden-file-input.tsx
+import React3 from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var HiddenFileInput = React3.forwardRef(({ value, name, form, isRequired }, ref) => {
+  const fileInputRef = React3.useRef(null);
+  React3.useEffect(() => {
+    if (fileInputRef.current) {
+      const dt = new DataTransfer();
+      if (Array.isArray(value)) {
+        value.forEach((v) => dt.items.add(v));
+      } else if (value) {
+        dt.items.add(value);
+      }
+      fileInputRef.current.files = dt.files;
+    }
+  }, [value]);
+  return /* @__PURE__ */ jsx2(
+    "input",
+    {
+      style: { display: "none" },
+      type: "file",
+      tabIndex: -1,
+      "aria-hidden": "true",
+      onChange: () => {
+      },
+      ref: composeRefs(fileInputRef, ref),
+      name,
+      form,
+      "aria-required": isRequired,
+      required: isRequired
+    }
+  );
+});
+HiddenFileInput.displayName = "HiddenFileInput";
+
+// src/hidden-input.tsx
+import React4 from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var HiddenInput = React4.forwardRef(({ value, name, form, isRequired, type, min, max }, ref) => {
+  return /* @__PURE__ */ jsx3(
+    "input",
+    {
+      style: {
+        border: 0,
+        clip: "rect(0 0 0 0)",
+        clipPath: "inset(50%)",
+        height: "1px",
+        margin: "-1px",
+        overflow: "hidden",
+        padding: 0,
+        position: "absolute",
+        width: "1px",
+        whiteSpace: "nowrap"
+      },
+      "aria-required": isRequired,
+      required: isRequired,
+      tabIndex: -1,
+      "aria-hidden": "true",
+      value,
+      onChange: () => {
+      },
+      ref,
+      name,
+      form,
+      type: type ?? "text",
+      min,
+      max
+    }
+  );
+});
+HiddenInput.displayName = "HiddenInput";
+
+// src/hidden-select.tsx
+import React5 from "react";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var HiddenSelect = React5.forwardRef(({ value, name, form, isRequired, children, autoComplete, onChange, label }, ref) => {
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      style: {
+        border: 0,
+        clip: "rect(0 0 0 0)",
+        clipPath: "inset(50%)",
+        height: "1px",
+        margin: "-1px",
+        overflow: "hidden",
+        padding: 0,
+        position: "absolute",
+        width: "1px",
+        whiteSpace: "nowrap"
+      },
+      children: /* @__PURE__ */ jsxs2("label", { children: [
+        label,
+        /* @__PURE__ */ jsxs2(
+          "select",
+          {
+            "aria-required": isRequired,
+            required: isRequired,
+            tabIndex: -1,
+            "aria-hidden": "true",
+            value,
+            ref,
+            name,
+            form,
+            autoComplete,
+            onChange,
+            children: [
+              /* @__PURE__ */ jsx4("option", { value: "" }),
+              children
+            ]
+          }
+        )
+      ] })
+    }
+  );
+});
+HiddenSelect.displayName = "HiddenSelect";
+
+// src/use-controlled-state.ts
+import React6 from "react";
+function useControlledState(value, defaultValue, onChange) {
+  let [stateValue, setStateValue] = React6.useState(value || defaultValue);
+  let isControlledRef = React6.useRef(value !== void 0);
+  let isControlled = value !== void 0;
+  React6.useEffect(() => {
+    let wasControlled = isControlledRef.current;
+    if (wasControlled !== isControlled) {
+      console.warn(
+        `WARN: A component changed from ${wasControlled ? "controlled" : "uncontrolled"} to ${isControlled ? "controlled" : "uncontrolled"}.`
+      );
+    }
+    isControlledRef.current = isControlled;
+  }, [isControlled]);
+  let currentValue = isControlled ? value : stateValue;
+  let setValue = React6.useCallback(
+    (value2, ...args) => {
+      let onChangeCaller = (value3, ...onChangeArgs) => {
+        if (onChange) {
+          if (!Object.is(currentValue, value3)) {
+            onChange(value3, ...onChangeArgs);
+          }
+        }
+        if (!isControlled) {
+          currentValue = value3;
+        }
+      };
+      if (typeof value2 === "function") {
+        console.warn(
+          "We can not support a function callback. See Github Issues for details https://github.com/adobe/react-spectrum/issues/2320"
+        );
+        let updateFunction = (oldValue, ...functionArgs) => {
+          let interceptedValue = value2(isControlled ? currentValue : oldValue, ...functionArgs);
+          onChangeCaller(interceptedValue, ...args);
+          if (!isControlled) {
+            return interceptedValue;
+          }
+          return oldValue;
+        };
+        setStateValue(updateFunction);
+      } else {
+        if (!isControlled) {
+          setStateValue(value2);
+        }
+        onChangeCaller(value2, ...args);
+      }
+    },
+    [isControlled, currentValue, onChange]
+  );
+  return [currentValue, setValue];
+}
+
+// src/use-form.ts
+import React8 from "react";
+
+// src/use-stable-accessor.ts
+import React7 from "react";
+function useStableAccessor(value) {
+  const initialPersisterKey = React7.useRef({ value });
+  const getValue = React7.useCallback(() => {
+    return initialPersisterKey.current.value;
+  }, [initialPersisterKey]);
+  initialPersisterKey.current.value = value;
+  return getValue;
+}
+
+// src/use-form.ts
+function useTopLevelFormValidation(formElement) {
+  const getForm = useStableAccessor(formElement);
+  const revalidate = React8.useCallback(
+    (field) => {
+      const formRef = getForm();
+      const formElement2 = typeof formRef === "string" ? document.getElementById(formRef) : formRef;
+      const form = formElement2 && formElement2 instanceof HTMLFormElement ? formElement2 : null;
+      const elements = form ? [...form.elements] : [];
+      const relevantElements = elements.filter((e) => !field || e.attributes.getNamedItem("name")?.value.startsWith(field));
+      relevantElements.forEach((e) => e.dispatchEvent(new Event("change")));
+    },
+    [getForm]
+  );
+  return { revalidate };
+}
+
+// src/use-reset.ts
+import React10 from "react";
+
+// src/use-effect-event.ts
+import React9 from "react";
+function useEffectEvent(fn) {
+  const ref = React9.useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    ref.current = fn;
+  }, [fn]);
+  return React9.useCallback((...args) => {
+    const f = ref.current;
+    return f(...args);
+  }, []);
+}
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React9.useLayoutEffect : React9.useEffect;
+
+// src/use-reset.ts
+function useReset(ref, initialValue, onReset) {
+  let resetValue = React10.useRef(initialValue);
+  let handleReset = useEffectEvent(() => {
+    if (onReset) {
+      onReset(resetValue.current);
+    }
+  });
+  React10.useEffect(() => {
+    let form = ref?.current?.form;
+    form?.addEventListener("reset", handleReset);
+    return () => {
+      form?.removeEventListener("reset", handleReset);
+    };
+  }, [ref, handleReset]);
+}
+
+// src/use-validation.ts
+import React12 from "react";
+
+// src/use-form-validation-state.ts
+import React11 from "react";
+var VALID_VALIDITY_STATE = {
+  badInput: false,
+  customError: false,
+  patternMismatch: false,
+  rangeOverflow: false,
+  rangeUnderflow: false,
+  stepMismatch: false,
+  tooLong: false,
+  tooShort: false,
+  typeMismatch: false,
+  valueMissing: false,
+  valid: true
+};
+var CUSTOM_VALIDITY_STATE = {
+  ...VALID_VALIDITY_STATE,
+  customError: true,
+  valid: false
+};
+var DEFAULT_VALIDATION_RESULT = {
+  isInvalid: false,
+  validationDetails: VALID_VALIDITY_STATE,
+  validationErrors: []
+};
+function useFormValidationState(props) {
+  let { isInvalid, name, value, builtinValidation, validate } = props;
+  const controlledError = isInvalid ? {
+    isInvalid: true,
+    validationErrors: [],
+    validationDetails: CUSTOM_VALIDITY_STATE
+  } : null;
+  let clientError = React11.useMemo(() => {
+    if (validate) {
+      return getValidationResult(runValidate(validate, value));
+    } else if (props.isRequired && (value === null || value === void 0 || value === "")) {
+      return {
+        isInvalid: true,
+        validationErrors: ["This field is required"],
+        validationDetails: {
+          ...VALID_VALIDITY_STATE,
+          valueMissing: true,
+          valid: false
+        }
+      };
+    } else {
+      return null;
+    }
+  }, [validate, value]);
+  if (builtinValidation?.validationDetails.valid) {
+    builtinValidation = void 0;
+  }
+  const serverErrors = useServerErrors(props.form);
+  const serverErrorMessages = React11.useMemo(() => {
+    if (name) {
+      return Array.isArray(name) ? name.flatMap((name2) => serverErrors.filter((s) => s.path === name2).map((s) => s.message)) : serverErrors.filter((s) => s.path === name).map((s) => s.message);
+    }
+    return [];
+  }, [serverErrors, name]);
+  let [lastServerErrors, setLastServerErrors] = React11.useState(serverErrors);
+  let [isServerErrorCleared, setServerErrorCleared] = React11.useState(false);
+  if (serverErrors !== lastServerErrors) {
+    setLastServerErrors(serverErrors);
+    setServerErrorCleared(false);
+  }
+  let serverError = React11.useMemo(
+    () => getValidationResult(isServerErrorCleared ? [] : serverErrorMessages),
+    [isServerErrorCleared, serverErrorMessages]
+  );
+  let nextValidation = React11.useRef(DEFAULT_VALIDATION_RESULT);
+  let [currentValidity, setCurrentValidity] = React11.useState(DEFAULT_VALIDATION_RESULT);
+  let lastError = React11.useRef(DEFAULT_VALIDATION_RESULT);
+  let commitValidation = () => {
+    if (!commitQueued) {
+      return;
+    }
+    setCommitQueued(false);
+    let error = clientError || builtinValidation || nextValidation.current;
+    if (!isEqualValidation(error, lastError.current)) {
+      lastError.current = error;
+      setCurrentValidity(error);
+    }
+  };
+  let [commitQueued, setCommitQueued] = React11.useState(false);
+  React11.useEffect(commitValidation);
+  let realtimeValidation = controlledError || serverError || clientError || builtinValidation || DEFAULT_VALIDATION_RESULT;
+  let displayValidation = controlledError || serverError || currentValidity;
+  return {
+    realtimeValidation,
+    displayValidation,
+    updateValidation(value2) {
+      nextValidation.current = value2;
+    },
+    resetValidation() {
+      let error = DEFAULT_VALIDATION_RESULT;
+      if (!isEqualValidation(error, lastError.current)) {
+        lastError.current = error;
+        setCurrentValidity(error);
+      }
+      setCommitQueued(false);
+      setServerErrorCleared(true);
+    },
+    commitValidation() {
+      setCommitQueued(true);
+      setServerErrorCleared(true);
+    }
+  };
+}
+function asArray(v) {
+  if (!v) {
+    return [];
+  }
+  return Array.isArray(v) ? v : [v];
+}
+function runValidate(validate, value) {
+  if (typeof validate === "function") {
+    let e = validate(value);
+    if (e && typeof e !== "boolean") {
+      return asArray(e);
+    }
+  }
+  return [];
+}
+function getValidationResult(errors) {
+  return errors.length ? {
+    isInvalid: true,
+    validationErrors: errors,
+    validationDetails: CUSTOM_VALIDITY_STATE
+  } : null;
+}
+function isEqualValidation(a, b) {
+  if (a === b) {
+    return true;
+  }
+  return !!a && !!b && a.isInvalid === b.isInvalid && a.validationErrors.length === b.validationErrors.length && a.validationErrors.every((a2, i) => a2 === b.validationErrors[i]) && Object.entries(a.validationDetails).every(([k, v]) => b.validationDetails[k] === v);
+}
+
+// src/use-validation.ts
+function useValidation(props, ref) {
+  const state = useFormValidationState(props);
+  let { focus } = props;
+  useIsomorphicLayoutEffect2(() => {
+    if (ref?.current) {
+      let errorMessage = state.realtimeValidation.isInvalid ? state.realtimeValidation.validationErrors.join(" ") || "Invalid value." : "";
+      ref.current.setCustomValidity(errorMessage);
+      if (!ref.current.hasAttribute("title")) {
+        ref.current.title = "";
+      }
+      if (!state.realtimeValidation.isInvalid) {
+        state.updateValidation(getNativeValidity(ref.current));
+      }
+    }
+  });
+  let onReset = useEffectEvent(() => {
+    state.resetValidation();
+  });
+  let onInvalid = useEffectEvent((e) => {
+    if (!state.displayValidation.isInvalid) {
+      state.commitValidation();
+    }
+    let form = ref?.current?.form;
+    if (!e.defaultPrevented && ref && form && getFirstInvalidInput(form) === ref.current) {
+      if (focus) {
+        focus();
+      } else {
+        ref.current?.focus();
+      }
+    }
+    e.preventDefault();
+  });
+  let onChange = useEffectEvent(() => {
+    state.commitValidation();
+  });
+  React12.useEffect(() => {
+    let input = ref?.current;
+    if (!input) {
+      return;
+    }
+    let form = input.form;
+    input.addEventListener("invalid", onInvalid);
+    input.addEventListener("change", onChange);
+    form?.addEventListener("reset", onReset);
+    return () => {
+      input.removeEventListener("invalid", onInvalid);
+      input.removeEventListener("change", onChange);
+      form?.removeEventListener("reset", onReset);
+    };
+  }, [ref, onInvalid, onChange, onReset]);
+  return {
+    commitValidation: state.commitValidation,
+    ...state.displayValidation,
+    validationMessage: state.displayValidation.validationErrors[0] ?? (state.displayValidation.isInvalid ? "invalid" : "")
+  };
+}
+var useIsomorphicLayoutEffect2 = typeof window !== "undefined" ? React12.useLayoutEffect : React12.useEffect;
+function getValidity(input) {
+  let validity = input.validity;
+  return {
+    badInput: validity.badInput,
+    customError: validity.customError,
+    patternMismatch: validity.patternMismatch,
+    rangeOverflow: validity.rangeOverflow,
+    rangeUnderflow: validity.rangeUnderflow,
+    stepMismatch: validity.stepMismatch,
+    tooLong: validity.tooLong,
+    tooShort: validity.tooShort,
+    typeMismatch: validity.typeMismatch,
+    valueMissing: validity.valueMissing,
+    valid: validity.valid
+  };
+}
+function getNativeValidity(input) {
+  return {
+    isInvalid: !input.validity.valid,
+    validationDetails: getValidity(input),
+    validationErrors: input.validationMessage ? [input.validationMessage] : []
+  };
+}
+function getFirstInvalidInput(form) {
+  for (let i = 0; i < form.elements.length; i++) {
+    let element = form.elements[i];
+    if (!element.validity.valid) {
+      return element;
+    }
+  }
+  return null;
+}
+
+// src/use-warning-state.ts
+import React13 from "react";
+var VALID_VALIDITY_STATE2 = {
+  badInput: false,
+  customError: false,
+  patternMismatch: false,
+  rangeOverflow: false,
+  rangeUnderflow: false,
+  stepMismatch: false,
+  tooLong: false,
+  tooShort: false,
+  typeMismatch: false,
+  valueMissing: false,
+  valid: true
+};
+var CUSTOM_VALIDITY_STATE2 = {
+  ...VALID_VALIDITY_STATE2,
+  customError: true,
+  valid: false
+};
+var DEFAULT_VALIDATION_RESULT2 = {
+  isInvalid: false,
+  validationDetails: VALID_VALIDITY_STATE2,
+  validationErrors: []
+};
+function useWarningState(props) {
+  let { isInvalid, value, validate } = props;
+  const controlledError = isInvalid ? {
+    isInvalid: true,
+    validationErrors: [],
+    validationDetails: CUSTOM_VALIDITY_STATE2
+  } : null;
+  let clientError = React13.useMemo(() => {
+    if (validate) {
+      return getValidationResult2(runValidate2(validate, value));
+    } else {
+      return null;
+    }
+  }, [validate, value]);
+  let nextValidation = React13.useRef(DEFAULT_VALIDATION_RESULT2);
+  let [currentValidity, setCurrentValidity] = React13.useState(DEFAULT_VALIDATION_RESULT2);
+  let lastError = React13.useRef(DEFAULT_VALIDATION_RESULT2);
+  let commitValidation = () => {
+    if (!commitQueued) {
+      return;
+    }
+    setCommitQueued(false);
+    let error = clientError || nextValidation.current;
+    if (!isEqualValidation2(error, lastError.current)) {
+      lastError.current = error;
+      setCurrentValidity(error);
+    }
+  };
+  let [commitQueued, setCommitQueued] = React13.useState(false);
+  React13.useEffect(commitValidation);
+  let realtimeValidation = controlledError || clientError || DEFAULT_VALIDATION_RESULT2;
+  let displayValidation = controlledError || currentValidity;
+  return {
+    realtimeValidation,
+    displayValidation,
+    updateValidation(value2) {
+      nextValidation.current = value2;
+    },
+    resetValidation() {
+      let error = DEFAULT_VALIDATION_RESULT2;
+      if (!isEqualValidation2(error, lastError.current)) {
+        lastError.current = error;
+        setCurrentValidity(error);
+      }
+      setCommitQueued(false);
+    },
+    commitValidation() {
+      setCommitQueued(true);
+    },
+    warningMessage: displayValidation.validationErrors[0] ?? (displayValidation.isInvalid ? "invalid" : "")
+  };
+}
+function asArray2(v) {
+  if (!v) {
+    return [];
+  }
+  return Array.isArray(v) ? v : [v];
+}
+function runValidate2(validate, value) {
+  if (typeof validate === "function") {
+    let e = validate(value);
+    if (e && typeof e !== "boolean") {
+      return asArray2(e);
+    }
+  }
+  return [];
+}
+function getValidationResult2(errors) {
+  return errors.length ? {
+    isInvalid: true,
+    validationErrors: errors,
+    validationDetails: CUSTOM_VALIDITY_STATE2
+  } : null;
+}
+function isEqualValidation2(a, b) {
+  if (a === b) {
+    return true;
+  }
+  return !!a && !!b && a.isInvalid === b.isInvalid && a.validationErrors.length === b.validationErrors.length && a.validationErrors.every((a2, i) => a2 === b.validationErrors[i]) && Object.entries(a.validationDetails).every(([k, v]) => b.validationDetails[k] === v);
+}
+
+// src/standard-schema-helpers.ts
+import set2 from "lodash.set";
+
+// src/json-schema-helpers.ts
+import set from "lodash.set";
+import get from "lodash.get";
+function parseJsonSchemaFormData(schema, formData) {
+  const flat = flattenJsonSchema(schema);
+  const booleans = flat.filter((f) => resolvedType(f.schema) === "boolean");
+  const arrays = flat.filter((f) => resolvedType(f.schema) === "array" && !f.optional && !f.path.includes(".*."));
+  const keys = [...arrays.map((a) => a.path), ...new Set(formData.keys())];
+  const rawEntries = keys.filter((key) => key !== "__formId").map((key) => {
+    const match = flat.find((f) => formPathsMatch(key, f.path));
+    return [key, coerceFormValue(match?.schema, formData.getAll(key))];
+  });
+  const obj = {};
+  rawEntries.forEach(([key, value]) => set(obj, key, value));
+  booleans.forEach((p) => {
+    const paths = resolveWildcardPath(p.path, obj);
+    paths.forEach((path) => {
+      if (get(obj, path) === void 0) {
+        set(obj, path, false);
+      }
+    });
+  });
+  return obj;
+}
+function flattenJsonSchema(schema) {
+  return flattenJsonSchemaHelper(schema, "", false);
+}
+function flattenJsonSchemaHelper(schema, prefix, optional) {
+  const type = resolvedType(schema);
+  const results = [];
+  const properties = schema.properties;
+  const items = schema.items;
+  const required = schema.required ?? [];
+  if (type === "object" && properties) {
+    for (const [key, child] of Object.entries(properties)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      const isOptional = !required.includes(key);
+      results.push({ path, schema: child, optional: isOptional });
+      results.push(...flattenJsonSchemaHelper(child, path, isOptional));
+    }
+  } else if (type === "array" && items) {
+    const path = prefix ? `${prefix}.*` : "*";
+    results.push({ path, schema: items, optional: false });
+    results.push(...flattenJsonSchemaHelper(items, path, false));
+  }
+  return results;
+}
+function coerceFormValue(schema, formValues) {
+  if (formValues.length && formValues.every((f) => f instanceof File)) {
+    if (formValues.every((f) => f instanceof File && f.name === "" && f.size === 0)) {
+      return schema && resolvedType(schema) === "array" ? [] : null;
+    }
+    return schema && resolvedType(schema) === "array" ? formValues : formValues[0];
+  }
+  if (!schema) {
+    return formValues.length === 1 ? formValues[0] : formValues;
+  }
+  const type = resolvedType(schema);
+  const items = schema.items;
+  if (type === "array") {
+    const rawValue = formValues;
+    if (rawValue.length === 1) {
+      if (rawValue[0] === "") return [];
+      try {
+        const parsed = JSON.parse(rawValue[0]);
+        if (Array.isArray(parsed)) return parsed;
+      } catch {
+      }
+    }
+    if (rawValue.length === 0) return isNullable(schema) ? null : [];
+    return items ? rawValue.map((v) => coerceScalar(v, items)) : rawValue;
+  }
+  return coerceScalar(formValues[0], schema);
+}
+function coerceScalar(value, schema) {
+  if (value === "" && isNullable(schema)) return null;
+  const type = resolvedType(schema);
+  if (type === "number" || type === "integer") {
+    return value === "" ? null : Number(value);
+  } else if (type === "boolean") {
+    return value === "true";
+  } else if (type === "string") {
+    return value;
+  } else {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value || null;
+    }
+  }
+}
+function resolvedType(schema) {
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    return type.find((t) => t !== "null") ?? "string";
+  }
+  return type;
+}
+function isNullable(schema) {
+  if (schema.nullable === true) return true;
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    return type.includes("null");
+  }
+  return type === "null";
+}
+function resolveWildcardPath(path, obj) {
+  if (path.includes(".*.")) {
+    const length = get(obj, path.slice(0, path.indexOf(".*.")), []).length;
+    const indices = Array.from({ length }, (_, i) => i);
+    const newPaths = indices.map((i) => path.replace(".*.", `.${i}.`));
+    return newPaths.flatMap((p) => resolveWildcardPath(p, obj));
+  }
+  return [path];
+}
+function formPathsMatch(path1, path2) {
+  const segments1 = path1.split(".");
+  const segments2 = path2.split(".");
+  return segments1.length === segments2.length && segments1.every((s1, i) => s1 === "*" || segments2[i] === "*" || s1 === segments2[i]);
+}
+
+// src/standard-schema-helpers.ts
+function parseFormDataClientSide(schema, formData, options) {
+  const formId = formData.get("__formId");
+  const jsonSchemaParsed = parseJsonSchemaFormData(schema["~standard"].jsonSchema.input({ target: "openapi-3.0" }), formData);
+  const files = findFiles(jsonSchemaParsed);
+  files.forEach((f) => set2(jsonSchemaParsed, f.path.join("."), "https://fakeurlforformuploading.com"));
+  const safeParsed = schema["~standard"].validate(jsonSchemaParsed, options);
+  if (isPromise(safeParsed)) {
+    throw new Error("Async validation not supported");
+  }
+  if (safeParsed.issues?.length) {
+    console.log([...formData.entries()].map((e) => [e[0], e[1]]));
+    console.log(jsonSchemaParsed);
+    return {
+      issues: [...safeParsed.issues.map((i) => ({ ...i, path: i.path ? [...i.path] : i.path }))],
+      data: jsonSchemaParsed,
+      formData,
+      formId,
+      success: false,
+      fileEntries: files
+    };
+  } else {
+    return { data: jsonSchemaParsed, issues: void 0, formData, formId, success: true, fileEntries: files };
+  }
+}
+async function parseFormData(schema, formData, options) {
+  formData = await formData;
+  const formId = formData.get("__formId");
+  const parsed1 = parseFormDataClientSide(schema, formData, options);
+  if (!parsed1.success) {
+    return { ...parsed1, formData };
+  } else if (options?.handleFile || !parsed1.fileEntries.length) {
+    const handleFile = options?.handleFile;
+    const uploadedFiles = await Promise.all(
+      parsed1.fileEntries.map(async (file) => ({
+        key: file.path.join("."),
+        value: await handleFile(file.value, file.path.join("."), parsed1.data)
+      }))
+    );
+    const obj2 = { ...parsed1.data };
+    uploadedFiles.forEach(({ key, value }) => set2(obj2, key, value));
+    const safeParsed2 = schema["~standard"].validate(obj2, options);
+    if (isPromise(safeParsed2)) {
+      throw new Error("Async validation not supported");
+    }
+    if (!safeParsed2.issues?.length) {
+      return { data: obj2, issues: void 0, formData, formId, success: true };
+    } else {
+      console.log(obj2);
+      console.log("fileEntries", parsed1.fileEntries);
+      return {
+        issues: [...safeParsed2.issues.map((i) => ({ ...i, path: i.path ? [...i.path] : i.path }))],
+        data: obj2,
+        formData,
+        formId,
+        success: false
+      };
+    }
+  } else {
+    throw new Error("A file was submitted but no file handler was provider");
+  }
+}
+function isPromise(p) {
+  return p && typeof p === "object" && !!p["then"];
+}
+function findFiles(input) {
+  const results = [];
+  const visited = /* @__PURE__ */ new WeakSet();
+  function walk(value, path) {
+    if (value === null || typeof value !== "object") return;
+    if (visited.has(value)) return;
+    visited.add(value);
+    if (value instanceof File) {
+      results.push({ path, value });
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((v, i) => walk(v, [...path, i]));
+      return;
+    }
+    if (value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set) return;
+    for (const [key, v] of Object.entries(value)) {
+      walk(v, [...path, key]);
+    }
+  }
+  walk(input, []);
+  return results;
+}
+
+// src/index.ts
+function composeValidators(...fns) {
+  return (value) => {
+    const errors = fns.flatMap((f) => f ? f(value) : []).filter(Boolean);
+    return errors;
+  };
+}
+var HeadlessForm = Object.assign(HeadlessFormRoot, {
+  GlobalProvider,
+  useValidation,
+  useWarningState,
+  useReset,
+  useControlledState,
+  HiddenInput,
+  HiddenFileInput,
+  HiddenSelect,
+  useServerErrors,
+  parseFormDataClientSide,
+  parseFormData,
+  useTopLevelFormValidation,
+  composeValidators
+});
+export {
+  HeadlessForm
+};