@holo-js/forms 0.1.4 → 0.1.5

package/dist/internal/client.mjs

@@ -0,0 +1,833 @@
+import {
+  clearSensitiveInputValues,
+  normalizeFailureErrors,
+  normalizeFailureInput,
+  normalizeStatus,
+  sanitizeFlashedInput
+} from "../chunk-WJOAU4V2.mjs";
+import {
+  createMissingSecurityPackageError,
+  isMissingOptionalPackageError,
+  parseCookieHeader
+} from "../chunk-GH4IN2OV.mjs";
+import {
+  FormContractError
+} from "../chunk-OFPH5LBY.mjs";
+
+// src/internal/client.ts
+import {
+  createErrorBag,
+  safeParse
+} from "@holo-js/validation";
+
+// src/client-security.ts
+var securityClientModulePromise;
+async function importSecurityClientModule() {
+  if (typeof process !== "undefined" && process.env && process.env.VITEST) {
+    return await import(
+      /* @vite-ignore */
+      "@holo-js/security/client"
+    );
+  }
+  return await import("@holo-js/security/client");
+}
+async function loadSecurityClientModule() {
+  const runtime = globalThis;
+  if (runtime.__holoFormsSecurityClientModule__) {
+    return runtime.__holoFormsSecurityClientModule__;
+  }
+  securityClientModulePromise ??= (runtime.__holoFormsSecurityClientImport__ ? runtime.__holoFormsSecurityClientImport__() : importSecurityClientModule()).then((module) => module).catch(async (error) => {
+    securityClientModulePromise = void 0;
+    if (isMissingOptionalPackageError(error)) {
+      throw createMissingSecurityPackageError();
+    }
+    throw error;
+  });
+  return await securityClientModulePromise;
+}
+async function getClientCsrfField() {
+  const runtime = globalThis;
+  if (!runtime.document || typeof runtime.document.cookie !== "string") {
+    return void 0;
+  }
+  let security;
+  try {
+    security = await loadSecurityClientModule();
+  } catch (error) {
+    if (error instanceof FormContractError) {
+      return void 0;
+    }
+    throw error;
+  }
+  const config = security.getSecurityClientConfig().csrf;
+  const value = parseCookieHeader(runtime.document.cookie)[config.cookie];
+  if (!value) {
+    return void 0;
+  }
+  return Object.freeze({
+    name: config.field,
+    value
+  });
+}
+
+// src/internal/validation-exception.ts
+import {
+  isValidationException,
+  validationInternals
+} from "@holo-js/validation";
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isErrorRecord(value) {
+  return isPlainObject(value) && Object.values(value).every((messages) => Array.isArray(messages) && messages.every((message) => typeof message === "string"));
+}
+function isFormFailurePayload(value) {
+  return isPlainObject(value) && value.ok === false && typeof value.status === "number" && value.valid === false && isPlainObject(value.values) && isErrorRecord(value.errors);
+}
+function readNestedPayload(value, path) {
+  let cursor = value;
+  for (const key of path) {
+    if (!isPlainObject(cursor)) {
+      return void 0;
+    }
+    cursor = cursor[key];
+  }
+  return cursor;
+}
+function formFailurePayloadFromError(error) {
+  const candidates = [
+    error,
+    readNestedPayload(error, ["data"]),
+    readNestedPayload(error, ["response", "_data"]),
+    readNestedPayload(error, ["response", "data"])
+  ];
+  return candidates.find((candidate) => isFormFailurePayload(candidate));
+}
+function validationExceptionToFailure(error, fallbackValues = {}) {
+  const payload = isValidationException(error) ? error.toJSON() : validationInternals.parseValidationExceptionDigest(error);
+  if (payload) {
+    return {
+      ok: false,
+      status: payload.status,
+      submitted: true,
+      valid: false,
+      values: payload.values && Object.keys(payload.values).length > 0 ? payload.values : fallbackValues,
+      errors: payload.errors,
+      ...typeof payload.retryAfterSeconds === "number" ? { retryAfterSeconds: payload.retryAfterSeconds } : {},
+      ...typeof payload.retryAt === "string" ? { retryAt: payload.retryAt } : {}
+    };
+  }
+  const formFailurePayload = formFailurePayloadFromError(error);
+  if (formFailurePayload) {
+    return {
+      ok: false,
+      status: formFailurePayload.status,
+      submitted: true,
+      valid: false,
+      values: Object.keys(formFailurePayload.values).length > 0 ? formFailurePayload.values : fallbackValues,
+      errors: formFailurePayload.errors,
+      ...typeof formFailurePayload.retryAfterSeconds === "number" ? { retryAfterSeconds: formFailurePayload.retryAfterSeconds } : {},
+      ...typeof formFailurePayload.retryAt === "string" ? { retryAt: formFailurePayload.retryAt } : {}
+    };
+  }
+  return void 0;
+}
+
+// src/internal/client.ts
+var browserFormSubmitSymbol = /* @__PURE__ */ Symbol("browserFormSubmit");
+function isBrowserFormSubmitter(value) {
+  return browserFormSubmitSymbol in value;
+}
+var transportFailureMessage = "Unable to submit the form right now. Please try again.";
+function serializeSubmissionState(valid, values, errors, schemaDefinition) {
+  return Object.freeze({
+    valid,
+    submitted: true,
+    values: sanitizeFlashedInput(values, schemaDefinition),
+    errors: errors.flatten()
+  });
+}
+function createSubmission(valid, values, errors, failureStatus = 422, schemaDefinition) {
+  const normalizedFailureStatus = normalizeStatus(failureStatus, 422);
+  const serialize = () => serializeSubmissionState(valid, values, errors, schemaDefinition);
+  const failure = (input) => {
+    const normalized = normalizeFailureInput(input, normalizedFailureStatus);
+    return {
+      ok: false,
+      status: normalized.status,
+      valid: false,
+      values: sanitizeFlashedInput(values, schemaDefinition),
+      errors: normalizeFailureErrors(errors.flatten(), normalized.errors)
+    };
+  };
+  const success = (payload, status) => ({
+    ok: true,
+    status: normalizeStatus(status, 200),
+    data: payload
+  });
+  if (valid) {
+    const data = values;
+    return Object.freeze({
+      valid: true,
+      submitted: true,
+      data,
+      values: data,
+      errors,
+      serialize,
+      success,
+      fail(input) {
+        return failure(input);
+      }
+    });
+  }
+  return Object.freeze({
+    valid: false,
+    submitted: true,
+    data: void 0,
+    values,
+    errors,
+    serialize,
+    success,
+    fail(input) {
+      return failure(input);
+    }
+  });
+}
+function createSuccessfulSubmission(schemaDefinition, data) {
+  return createSubmission(true, data, createErrorBag(), 422, schemaDefinition);
+}
+function createFailedSubmission(schemaDefinition, values, flattenedErrors, status = 422) {
+  void schemaDefinition;
+  return createSubmission(
+    false,
+    values,
+    createErrorBag(flattenedErrors),
+    normalizeStatus(status, 422),
+    schemaDefinition
+  );
+}
+function createTransportFailure(values, status = 500) {
+  return {
+    ok: false,
+    status: normalizeStatus(status, 500),
+    submitted: true,
+    valid: false,
+    values,
+    errors: {
+      _root: [transportFailureMessage]
+    }
+  };
+}
+async function validateClientValues(values, schemaDefinition) {
+  const result = await safeParse(
+    values,
+    schemaDefinition
+  );
+  if (result.valid) {
+    return createSuccessfulSubmission(schemaDefinition, result.data);
+  }
+  return createFailedSubmission(
+    schemaDefinition,
+    result.values,
+    result.errors.flatten()
+  );
+}
+function isPlainObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Blob);
+}
+function isSchemaFieldLike(value) {
+  return !!value && typeof value === "object" && value.kind === "field" && !!value.definition && typeof value.definition === "object";
+}
+function areEqual(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime();
+  }
+  if (left instanceof Blob || right instanceof Blob) {
+    return false;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => areEqual(value, right[index]));
+  }
+  if (isPlainObject2(left) && isPlainObject2(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => key in right && areEqual(left[key], right[key]));
+  }
+  return false;
+}
+function cloneValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneValue(item));
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (isPlainObject2(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, cloneValue(entry)])
+    );
+  }
+  return value;
+}
+function isLeafValue(value) {
+  return Array.isArray(value) || value instanceof Date || value instanceof Blob || isSchemaFieldLike(value) || !isPlainObject2(value);
+}
+function normalizeObject(value) {
+  return isPlainObject2(value) ? cloneValue(value) : {};
+}
+function mergeValues(base, override) {
+  if (!override || !isPlainObject2(override)) {
+    return cloneValue(base);
+  }
+  const output = cloneValue(base);
+  for (const [key, value] of Object.entries(override)) {
+    if (typeof value === "undefined" && key in output) {
+      continue;
+    }
+    if (isPlainObject2(value) && isPlainObject2(output[key])) {
+      output[key] = mergeValues(output[key], value);
+      continue;
+    }
+    output[key] = cloneValue(value);
+  }
+  return output;
+}
+function splitPath(path) {
+  return path.split(".").map((part) => part.trim()).filter(Boolean);
+}
+function getValueAtPath(root, path) {
+  let cursor = root;
+  for (const part of splitPath(path)) {
+    if (!isPlainObject2(cursor) && !Array.isArray(cursor)) {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function setValueAtPath(root, path, value) {
+  const parts = splitPath(path);
+  let cursor = root;
+  for (const [index, part] of parts.entries()) {
+    const last = index === parts.length - 1;
+    const nextPart = parts[index + 1];
+    if (Array.isArray(cursor)) {
+      const offset = Number(part);
+      if (!Number.isInteger(offset) || offset < 0) {
+        return;
+      }
+      if (last) {
+        cursor[offset] = value;
+        return;
+      }
+      const existing2 = cursor[offset];
+      if (!isPlainObject2(existing2) && !Array.isArray(existing2)) {
+        cursor[offset] = /^\d+$/.test(nextPart) ? [] : {};
+      }
+      cursor = cursor[offset];
+      continue;
+    }
+    if (last) {
+      cursor[part] = value;
+      return;
+    }
+    const existing = cursor[part];
+    if (!isPlainObject2(existing) && !Array.isArray(existing)) {
+      cursor[part] = /^\d+$/.test(nextPart) ? [] : {};
+    }
+    cursor = cursor[part];
+  }
+}
+function flattenLeafPaths(value, prefix = "") {
+  if (isLeafValue(value)) {
+    return [prefix].filter(Boolean);
+  }
+  return Object.entries(value).flatMap(([key, nested]) => {
+    const next = prefix ? `${prefix}.${key}` : key;
+    return flattenLeafPaths(nested, next);
+  });
+}
+function buildFormData(value, path = "", formData = new FormData()) {
+  if (typeof value === "undefined") {
+    return formData;
+  }
+  if (value instanceof Date) {
+    formData.append(path, value.toISOString());
+    return formData;
+  }
+  if (value instanceof Blob) {
+    formData.append(path, value);
+    return formData;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      buildFormData(item, `${path}[]`, formData);
+    }
+    return formData;
+  }
+  if (isPlainObject2(value)) {
+    for (const [key, nested] of Object.entries(value)) {
+      const next = path ? `${path}.${key}` : key;
+      buildFormData(nested, next, formData);
+    }
+    return formData;
+  }
+  formData.append(path, String(value));
+  return formData;
+}
+function getActiveElementBrowserForm() {
+  const activeElement = globalThis.document?.activeElement;
+  return activeElement?.form ?? void 0;
+}
+function getActiveBrowserFormData(form) {
+  if (!form) {
+    return void 0;
+  }
+  try {
+    return Reflect.construct(FormData, [form]);
+  } catch {
+    return void 0;
+  }
+}
+async function runWithBrowserFormElement(formClient, form) {
+  if (isBrowserFormSubmitter(formClient)) {
+    return await formClient[browserFormSubmitSymbol](form);
+  }
+  return await formClient.submit();
+}
+function createTypedErrorBag(flattenedErrors) {
+  return createErrorBag(flattenedErrors);
+}
+function notifyListeners(state) {
+  for (const listener of state.listeners) {
+    listener();
+  }
+}
+function nextValidationSequence(state) {
+  state.validationSequence += 1;
+  return state.validationSequence;
+}
+function isLatestValidation(state, sequence) {
+  return sequence === state.validationSequence;
+}
+function collectErrorsForPath(flattenedErrors, path) {
+  const direct = flattenedErrors[path] ?? [];
+  const prefix = `${path}.`;
+  const nested = Object.entries(flattenedErrors).filter(([key]) => key.startsWith(prefix)).flatMap(([, messages]) => messages);
+  return direct.length > 0 || nested.length > 0 ? [...direct, ...nested] : [];
+}
+function replaceErrorsForPath(flattenedErrors, path, nextErrors) {
+  const prefix = `${path}.`;
+  const merged = Object.fromEntries(
+    Object.entries(flattenedErrors).filter(([key]) => key !== path && !key.startsWith(prefix))
+  );
+  for (const [key, messages] of Object.entries(nextErrors)) {
+    if (key === path || key.startsWith(prefix)) {
+      merged[key] = messages;
+    }
+  }
+  return merged;
+}
+function buildFieldsTree(state, schemaDefinition, source, validateOn, prefix = "") {
+  if (isLeafValue(source)) {
+    const path = prefix;
+    return Object.freeze({
+      get value() {
+        return getValueAtPath(state.values, path);
+      },
+      set value(next) {
+        void this.set(next);
+      },
+      get errors() {
+        return collectErrorsForPath(state.flattenedErrors, path);
+      },
+      get touched() {
+        return state.touched.has(path);
+      },
+      get dirty() {
+        return state.dirty.has(path);
+      },
+      async set(value) {
+        setValueAtPath(state.values, path, value);
+        state.touched.add(path);
+        if (!areEqual(getValueAtPath(state.initialValues, path), value)) {
+          state.dirty.add(path);
+        } else {
+          state.dirty.delete(path);
+        }
+        if (validateOn === "change") {
+          const sequence = nextValidationSequence(state);
+          const submission = await validateClientValues(
+            cloneValue(state.values),
+            schemaDefinition
+          );
+          if (isLatestValidation(state, sequence)) {
+            state.flattenedErrors = submission.errors.flatten();
+          }
+        }
+        notifyListeners(state);
+      },
+      async onInput(value) {
+        await this.set(value);
+      },
+      async onBlur() {
+        state.touched.add(path);
+        if (validateOn === "blur") {
+          const sequence = nextValidationSequence(state);
+          const submission = await validateClientValues(
+            cloneValue(state.values),
+            schemaDefinition
+          );
+          if (isLatestValidation(state, sequence)) {
+            state.flattenedErrors = replaceErrorsForPath(
+              state.flattenedErrors,
+              path,
+              submission.errors.flatten()
+            );
+          }
+        }
+        notifyListeners(state);
+      },
+      async validate() {
+        const sequence = nextValidationSequence(state);
+        const submission = await validateClientValues(cloneValue(state.values), schemaDefinition);
+        if (isLatestValidation(state, sequence)) {
+          state.flattenedErrors = submission.errors.flatten();
+          notifyListeners(state);
+        }
+        return state.flattenedErrors[path] ?? [];
+      }
+    });
+  }
+  const entries = Object.entries(source).map(([key, value]) => {
+    const next = prefix ? `${prefix}.${key}` : key;
+    return [key, buildFieldsTree(state, schemaDefinition, value, validateOn, next)];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+function isSubmissionResult(value) {
+  return "valid" in value && "errors" in value && "values" in value && !!value.errors && typeof value.errors === "object" && "flatten" in value.errors && typeof value.errors.flatten === "function";
+}
+function isSerializedSubmission(value) {
+  return "submitted" in value && "errors" in value && "values" in value && !("ok" in value);
+}
+function isFormFailurePayload2(value) {
+  return isPlainObject2(value) && value.ok === false && typeof value.status === "number" && value.valid === false && isPlainObject2(value.values) && isPlainObject2(value.errors);
+}
+function isSvelteKitActionFailureResult(value) {
+  return isPlainObject2(value) && value.type === "failure" && typeof value.status === "number" && typeof value.data === "string";
+}
+function isSvelteKitActionErrorResult(value) {
+  return isPlainObject2(value) && value.type === "error" && isPlainObject2(value.error);
+}
+function parseJsonObject(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeSvelteKitActionResult(result) {
+  const payload = isSvelteKitActionFailureResult(result) ? parseJsonObject(result.data) : isSvelteKitActionErrorResult(result) ? result.error : void 0;
+  if (!isFormFailurePayload2(payload)) {
+    return void 0;
+  }
+  return {
+    ...payload,
+    submitted: true
+  };
+}
+function normalizeSubmissionLike(schemaDefinition, values, result) {
+  const svelteKitActionResult = normalizeSvelteKitActionResult(result);
+  if (svelteKitActionResult) {
+    return svelteKitActionResult;
+  }
+  if (isSubmissionResult(result)) {
+    return result;
+  }
+  if ("ok" in result && result.ok === false && "status" in result && "errors" in result && "values" in result) {
+    return {
+      ok: false,
+      status: result.status,
+      submitted: true,
+      valid: false,
+      values: result.values,
+      errors: result.errors,
+      ...result.status === 429 && "retryAfter" in result ? { retryAfter: result.retryAfter } : {},
+      ...result.status === 429 && "retryAt" in result ? { retryAt: result.retryAt } : {}
+    };
+  }
+  if (isSerializedSubmission(result)) {
+    if (result.valid) {
+      return createSuccessfulSubmission(schemaDefinition, result.values);
+    }
+    return createFailedSubmission(schemaDefinition, result.values, result.errors);
+  }
+  if ("ok" in result && result.ok === true) {
+    return {
+      ok: true,
+      status: result.status,
+      data: result.data
+    };
+  }
+  return createSuccessfulSubmission(schemaDefinition, values);
+}
+function appendQueryString(action, formData) {
+  const [rawPath = "", hash = ""] = action.split("#", 2);
+  const [pathname = "", search = ""] = rawPath.split("?", 2);
+  const params = new URLSearchParams(search);
+  for (const [key, value] of formData.entries()) {
+    params.append(key, typeof value === "string" ? value : value.name);
+  }
+  const query = params.toString();
+  const suffix = hash ? `#${hash}` : "";
+  return query ? `${pathname}?${query}${suffix}` : `${pathname}${suffix}`;
+}
+function isJsonResponse(response) {
+  const contentType = response.headers?.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  return contentType === "application/json" || contentType?.endsWith("+json") === true;
+}
+async function normalizeFetchResponse(response, fallbackValues) {
+  if (response.status === 204 || response.status === 205) {
+    return {
+      ok: true,
+      status: response.status,
+      data: void 0
+    };
+  }
+  if (isJsonResponse(response)) {
+    return await response.json();
+  }
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: void 0
+    };
+  }
+  try {
+    return await response.json();
+  } catch {
+    return createTransportFailure(fallbackValues, response.status);
+  }
+}
+async function defaultSubmitter(context) {
+  if (typeof fetch !== "function" || !context.action) {
+    return {
+      ok: true,
+      status: 200,
+      data: context.values
+    };
+  }
+  const method = context.method.toUpperCase();
+  if (method === "GET" || method === "HEAD") {
+    const response2 = await fetch(appendQueryString(context.action, context.formData), {
+      method
+    });
+    if (method === "HEAD" || response2.status === 204 || response2.status === 205) {
+      return {
+        ok: true,
+        status: response2.status,
+        data: void 0
+      };
+    }
+    return await normalizeFetchResponse(response2, context.values);
+  }
+  const response = await fetch(context.action, {
+    method,
+    body: context.formData
+  });
+  return await normalizeFetchResponse(response, context.values);
+}
+function isSafeMethod(method) {
+  const normalized = method.trim().toUpperCase();
+  return normalized === "GET" || normalized === "HEAD" || normalized === "OPTIONS" || normalized === "TRACE";
+}
+function createFormClient(schemaDefinition, options = {}) {
+  const initialState = options.initialState ?? void 0;
+  const initialValues = mergeValues(
+    normalizeObject(options.initialValues),
+    normalizeObject(initialState?.values)
+  );
+  const state = {
+    values: cloneValue(initialValues),
+    initialValues: cloneValue(initialValues),
+    flattenedErrors: { ...initialState?.errors ?? {} },
+    touched: /* @__PURE__ */ new Set(),
+    dirty: /* @__PURE__ */ new Set(),
+    submitting: false,
+    lastSubmission: initialState,
+    listeners: /* @__PURE__ */ new Set(),
+    validationSequence: 0
+  };
+  const validateOn = options.validateOn ?? "submit";
+  const fieldPaths = flattenLeafPaths(schemaDefinition.fields);
+  const fields = buildFieldsTree(
+    state,
+    schemaDefinition,
+    schemaDefinition.fields,
+    validateOn
+  );
+  async function runValidation() {
+    return await runValidationForInput(cloneValue(state.values));
+  }
+  async function runValidationForInput(input) {
+    const sequence = nextValidationSequence(state);
+    const submission = await validateClientValues(input, schemaDefinition);
+    if (isLatestValidation(state, sequence)) {
+      state.values = mergeValues(
+        state.values,
+        submission.valid ? submission.data : submission.values
+      );
+      state.flattenedErrors = submission.errors.flatten();
+      notifyListeners(state);
+    }
+    return submission;
+  }
+  function applyServerState(result) {
+    const normalized = normalizeSubmissionLike(
+      schemaDefinition,
+      state.values,
+      result
+    );
+    if ("ok" in normalized && normalized.ok === true) {
+      state.lastSubmission = normalized;
+      state.flattenedErrors = {};
+      notifyListeners(state);
+      return normalized;
+    }
+    if ("ok" in normalized && normalized.ok === false) {
+      const sanitized = {
+        ...normalized,
+        values: sanitizeFlashedInput(normalized.values, schemaDefinition)
+      };
+      state.values = mergeValues(state.values, sanitized.values);
+      clearSensitiveInputValues(state.values, schemaDefinition);
+      state.flattenedErrors = sanitized.errors;
+      state.lastSubmission = sanitized;
+      notifyListeners(state);
+      return sanitized;
+    }
+    const normalizedSubmission = normalized;
+    state.values = mergeValues(state.values, normalizedSubmission.values);
+    clearSensitiveInputValues(state.values, schemaDefinition);
+    state.flattenedErrors = normalizedSubmission.errors.flatten();
+    state.lastSubmission = normalizedSubmission.valid ? void 0 : normalizedSubmission.fail();
+    notifyListeners(state);
+    return normalizedSubmission;
+  }
+  async function submit(browserForm) {
+    state.submitting = true;
+    notifyListeners(state);
+    try {
+      const submitter = options.submitter ?? defaultSubmitter;
+      const liveForm = browserForm ?? getActiveElementBrowserForm();
+      const method = options.method ?? liveForm?.method ?? "POST";
+      const action = options.action ?? liveForm?.action;
+      const liveFormData = getActiveBrowserFormData(liveForm);
+      const formData = liveFormData ?? buildFormData(state.values);
+      const localSubmission = liveFormData ? await runValidationForInput(liveFormData) : await runValidation();
+      if (!localSubmission.valid) {
+        return localSubmission;
+      }
+      if (!isSafeMethod(method)) {
+        const csrfField = await getClientCsrfField();
+        if (csrfField) {
+          formData.set(csrfField.name, csrfField.value);
+        }
+      }
+      let response;
+      try {
+        response = await submitter({
+          action,
+          method,
+          values: localSubmission.data,
+          formData
+        });
+      } catch (error) {
+        return applyServerState(
+          validationExceptionToFailure(error, state.values) ?? createTransportFailure(state.values)
+        );
+      }
+      return applyServerState(response ?? {
+        ok: true,
+        status: 204,
+        data: void 0
+      });
+    } finally {
+      state.submitting = false;
+      notifyListeners(state);
+    }
+  }
+  return Object.freeze({
+    fields,
+    get values() {
+      return state.values;
+    },
+    get errors() {
+      return createTypedErrorBag(state.flattenedErrors);
+    },
+    get submitting() {
+      return state.submitting;
+    },
+    get valid() {
+      return Object.keys(state.flattenedErrors).length === 0;
+    },
+    get lastSubmission() {
+      return state.lastSubmission;
+    },
+    subscribe(listener) {
+      state.listeners.add(listener);
+      return () => {
+        state.listeners.delete(listener);
+      };
+    },
+    async validate() {
+      return runValidation();
+    },
+    async validateField(path) {
+      const submission = await runValidation();
+      return submission.errors.get(path);
+    },
+    submit() {
+      return submit();
+    },
+    [browserFormSubmitSymbol](form) {
+      return submit(form);
+    },
+    reset(values) {
+      const next = mergeValues(state.initialValues, values);
+      state.values = cloneValue(next);
+      state.initialValues = cloneValue(next);
+      state.flattenedErrors = {};
+      state.touched.clear();
+      state.dirty.clear();
+      state.lastSubmission = void 0;
+      notifyListeners(state);
+    },
+    async setValue(path, value) {
+      setValueAtPath(state.values, path, value);
+      state.touched.add(path);
+      if (!areEqual(getValueAtPath(state.initialValues, path), value)) {
+        state.dirty.add(path);
+      } else {
+        state.dirty.delete(path);
+      }
+      if (validateOn === "change" && fieldPaths.includes(path)) {
+        await runValidation();
+        return;
+      }
+      notifyListeners(state);
+    },
+    applyServerState(result) {
+      return applyServerState(result);
+    }
+  });
+}
+export {
+  createFormClient,
+  runWithBrowserFormElement
+};