@holo-js/forms 0.1.3 → 0.1.5

package/dist/client.mjs

@@ -1,527 +0,0 @@
-import {
-  FormContractError,
-  createFailedSubmission,
-  createSuccessfulSubmission,
-  formsSecurityInternals,
-  validate
-} from "./chunk-663LOLKH.mjs";
-
-// src/client.ts
-import { createErrorBag } from "@holo-js/validation";
-
-// src/client-security.ts
-var securityClientModulePromise;
-async function importSecurityClientModule() {
-  if (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 (formsSecurityInternals.isMissingOptionalPackageError(error)) {
-      throw formsSecurityInternals.createMissingSecurityPackageError();
-    }
-    throw error;
-  });
-  return await securityClientModulePromise;
-}
-async function getClientCsrfField() {
-  const runtime = globalThis;
-  if (!runtime.document || typeof runtime.document.cookie !== "string") {
-    throw new FormContractError(
-      "[@holo-js/forms] useForm({ csrf: true }) requires a browser-like document.cookie environment."
-    );
-  }
-  const security = await loadSecurityClientModule();
-  const config = security.getSecurityClientConfig().csrf;
-  const value = formsSecurityInternals.parseCookieHeader(runtime.document.cookie)[config.cookie];
-  if (!value) {
-    throw new FormContractError(
-      `[@holo-js/forms] Missing CSRF cookie "${config.cookie}" required by useForm({ csrf: true }).`
-    );
-  }
-  return Object.freeze({
-    name: config.field,
-    value
-  });
-}
-
-// src/client.ts
-function isPlainObject(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 (isPlainObject(left) && isPlainObject(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 (isPlainObject(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) || !isPlainObject(value);
-}
-function normalizeObject(value) {
-  return isPlainObject(value) ? cloneValue(value) : {};
-}
-function mergeValues(base, override) {
-  if (!override || !isPlainObject(override)) {
-    return cloneValue(base);
-  }
-  const output = cloneValue(base);
-  for (const [key, value] of Object.entries(override)) {
-    if (isPlainObject(value) && isPlainObject(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 (!isPlainObject(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 (!isPlainObject(existing2) && !Array.isArray(existing2)) {
-        cursor[offset] = /^\d+$/.test(nextPart) ? [] : {};
-      }
-      cursor = cursor[offset];
-      continue;
-    }
-    if (last) {
-      cursor[part] = value;
-      return;
-    }
-    const existing = cursor[part];
-    if (!isPlainObject(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 (isPlainObject(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 createTypedErrorBag(flattenedErrors) {
-  return createErrorBag(flattenedErrors);
-}
-function notifyListeners(state) {
-  for (const listener of state.listeners) {
-    listener();
-  }
-}
-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 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 submission = await validate(state.values, schemaDefinition);
-          state.flattenedErrors = submission.errors.flatten();
-          state.lastSubmission = submission.serialize();
-        }
-        notifyListeners(state);
-      },
-      async onInput(value) {
-        await this.set(value);
-      },
-      async onBlur() {
-        state.touched.add(path);
-        if (validateOn === "blur") {
-          const submission = await validate(state.values, schemaDefinition);
-          state.flattenedErrors = submission.errors.flatten();
-          state.lastSubmission = submission.serialize();
-        }
-        notifyListeners(state);
-      },
-      async validate() {
-        const submission = await validate(state.values, schemaDefinition);
-        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 normalizeSubmissionLike(schemaDefinition, values, result) {
-  if (isSubmissionResult(result)) {
-    return result;
-  }
-  if ("ok" in result && result.ok === false && "errors" in result && "values" in result) {
-    return {
-      ...result,
-      submitted: true
-    };
-  }
-  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 result;
-  }
-  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 {
-      ok: false,
-      status: response.status,
-      valid: false,
-      values: fallbackValues,
-      errors: {}
-    };
-  }
-}
-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 useForm(schemaDefinition, options = {}) {
-  const initialValues = mergeValues(
-    normalizeObject(options.initialState?.values),
-    options.initialValues
-  );
-  const state = {
-    values: cloneValue(initialValues),
-    initialValues: cloneValue(initialValues),
-    flattenedErrors: { ...options.initialState?.errors ?? {} },
-    touched: /* @__PURE__ */ new Set(),
-    dirty: /* @__PURE__ */ new Set(),
-    submitting: false,
-    lastSubmission: options.initialState,
-    listeners: /* @__PURE__ */ new Set()
-  };
-  const validateOn = options.validateOn ?? "submit";
-  const fieldPaths = flattenLeafPaths(schemaDefinition.fields);
-  const fields = buildFieldsTree(
-    state,
-    schemaDefinition,
-    schemaDefinition.fields,
-    validateOn
-  );
-  async function runValidation() {
-    const submission = await validate(state.values, schemaDefinition);
-    state.flattenedErrors = submission.errors.flatten();
-    state.lastSubmission = submission.serialize();
-    notifyListeners(state);
-    return submission;
-  }
-  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);
-    },
-    async submit() {
-      state.submitting = true;
-      notifyListeners(state);
-      try {
-        const local = await runValidation();
-        if (!local.valid) {
-          return local;
-        }
-        const submitter = options.submitter ?? defaultSubmitter;
-        const method = options.method ?? "POST";
-        const formData = buildFormData(state.values);
-        if (options.csrf === true && !isSafeMethod(method)) {
-          const csrfField = await getClientCsrfField();
-          formData.set(csrfField.name, csrfField.value);
-        }
-        const response = await submitter({
-          action: options.action,
-          method,
-          values: state.values,
-          formData
-        });
-        return this.applyServerState(response);
-      } finally {
-        state.submitting = false;
-        notifyListeners(state);
-      }
-    },
-    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)) {
-        const submission = await runValidation();
-        state.flattenedErrors = submission.errors.flatten();
-        return;
-      }
-      notifyListeners(state);
-    },
-    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) {
-        state.values = mergeValues(state.values, normalized.values);
-        state.flattenedErrors = normalized.errors;
-        state.lastSubmission = {
-          valid: false,
-          submitted: true,
-          values: normalized.values,
-          errors: normalized.errors
-        };
-        notifyListeners(state);
-        return normalized;
-      }
-      const normalizedSubmission = normalized;
-      state.values = mergeValues(state.values, normalizedSubmission.values);
-      state.flattenedErrors = normalizedSubmission.errors.flatten();
-      state.lastSubmission = normalizedSubmission.serialize();
-      notifyListeners(state);
-      return normalizedSubmission;
-    }
-  });
-}
-export {
-  useForm
-};