@holo-js/forms 0.1.0

package/dist/chunk-Z6TEFT7S.mjs

@@ -0,0 +1,124 @@
+// src/contracts.ts
+import {
+  createErrorBag,
+  defineSchema,
+  isValidationSchema,
+  validate as validateInput
+} from "@holo-js/validation";
+var FormContractError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FormContractError";
+  }
+};
+function schema(shapeOrSchema) {
+  const base = isValidationSchema(shapeOrSchema) ? shapeOrSchema : defineSchema(shapeOrSchema);
+  return Object.freeze({
+    ...base,
+    mode: "form"
+  });
+}
+function isFormSchema(value) {
+  return isValidationSchema(value) && value.mode === "form";
+}
+function normalizeStatus(value, fallback) {
+  if (typeof value === "undefined") {
+    return fallback;
+  }
+  if (!Number.isInteger(value) || value < 100) {
+    throw new FormContractError("HTTP status codes must be integers greater than or equal to 100.");
+  }
+  return value;
+}
+function serializeSubmissionState(valid, values, errors) {
+  return Object.freeze({
+    valid,
+    submitted: true,
+    values,
+    errors: errors.flatten()
+  });
+}
+function createSubmission(valid, values, errors) {
+  const serialize = () => serializeSubmissionState(valid, values, errors);
+  const failure = () => ({
+    ok: false,
+    status: 422,
+    valid: false,
+    values,
+    errors: errors.flatten()
+  });
+  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(status) {
+        const payload = failure();
+        return {
+          ...payload,
+          status: normalizeStatus(status, payload.status)
+        };
+      }
+    });
+  }
+  return Object.freeze({
+    valid: false,
+    submitted: true,
+    data: void 0,
+    values,
+    errors,
+    serialize,
+    success,
+    fail(status) {
+      const payload = failure();
+      return {
+        ...payload,
+        status: normalizeStatus(status, payload.status)
+      };
+    }
+  });
+}
+function createSuccessfulSubmission(schemaDefinition, data) {
+  void schemaDefinition;
+  return createSubmission(true, data, createErrorBag());
+}
+function createFailedSubmission(schemaDefinition, values, flattenedErrors) {
+  void schemaDefinition;
+  return createSubmission(
+    false,
+    values,
+    createErrorBag(flattenedErrors)
+  );
+}
+async function validate(input, schemaDefinition) {
+  const result = await validateInput(input, schemaDefinition);
+  if (result.valid) {
+    return createSuccessfulSubmission(schemaDefinition, result.data);
+  }
+  return createFailedSubmission(schemaDefinition, result.values, result.errors.flatten());
+}
+var formsInternals = {
+  createSubmission,
+  normalizeStatus,
+  serializeSubmissionState
+};
+
+export {
+  FormContractError,
+  schema,
+  isFormSchema,
+  createSuccessfulSubmission,
+  createFailedSubmission,
+  validate,
+  formsInternals
+};

package/dist/client.d.ts

@@ -0,0 +1,51 @@
+import { FormSubmissionResult, SerializedFormSubmission, FormFailurePayload, FormSuccessPayload, FormSchema } from './index.js';
+import { WebFileLike, ValidationErrorBag, SchemaInputShape, InferSchemaData } from '@holo-js/validation';
+
+type PrimitiveLike = string | number | boolean | bigint | symbol | null | undefined | Date | Blob | WebFileLike;
+type ValidateOnMode = 'submit' | 'blur' | 'change';
+interface ClientSubmitContext<TData> {
+    readonly action?: string;
+    readonly method: string;
+    readonly values: TData;
+    readonly formData: FormData;
+}
+type ClientSubmitResult<TData> = FormSubmissionResult<TData> | SerializedFormSubmission<TData> | FormFailurePayload<TData> | FormSuccessPayload<unknown>;
+interface UseFormOptions<TData> {
+    readonly action?: string;
+    readonly method?: string;
+    readonly validateOn?: ValidateOnMode;
+    readonly initialValues?: Partial<TData>;
+    readonly initialState?: SerializedFormSubmission<TData>;
+    readonly submitter?: (context: ClientSubmitContext<TData>) => Promise<ClientSubmitResult<TData>> | ClientSubmitResult<TData>;
+}
+interface FormFieldState<TValue> {
+    value: TValue;
+    readonly errors: readonly string[];
+    readonly touched: boolean;
+    readonly dirty: boolean;
+    set(value: TValue): Promise<void>;
+    onInput(value: TValue): Promise<void>;
+    onBlur(): Promise<void>;
+    validate(): Promise<readonly string[]>;
+}
+type FormFieldTree<TData> = TData extends readonly unknown[] ? FormFieldState<TData> : TData extends PrimitiveLike ? FormFieldState<TData> : TData extends Record<string, unknown> ? {
+    readonly [K in keyof TData]: FormFieldTree<TData[K]>;
+} : FormFieldState<TData>;
+interface UseFormResult<TData> {
+    readonly fields: FormFieldTree<TData>;
+    readonly values: TData;
+    readonly errors: ValidationErrorBag<TData>;
+    readonly submitting: boolean;
+    readonly valid: boolean;
+    readonly lastSubmission?: SerializedFormSubmission<TData> | FormSuccessPayload<unknown>;
+    subscribe(listener: () => void): () => void;
+    validate(): Promise<FormSubmissionResult<TData>>;
+    validateField(path: string): Promise<readonly string[]>;
+    submit(): Promise<ClientSubmitResult<TData>>;
+    reset(values?: Partial<TData>): void;
+    setValue(path: string, value: unknown): Promise<void>;
+    applyServerState(result: ClientSubmitResult<TData>): ClientSubmitResult<TData>;
+}
+declare function useForm<TSchema extends FormSchema<SchemaInputShape>>(schemaDefinition: TSchema, options?: UseFormOptions<InferSchemaData<TSchema['fields']>>): UseFormResult<InferSchemaData<TSchema['fields']>>;
+
+export { type ClientSubmitContext, type ClientSubmitResult, type FormFieldState, type FormFieldTree, type UseFormOptions, type UseFormResult, type ValidateOnMode, useForm };

package/dist/client.mjs

@@ -0,0 +1,467 @@
+import {
+  createFailedSubmission,
+  createSuccessfulSubmission,
+  validate
+} from "./chunk-Z6TEFT7S.mjs";
+
+// src/client.ts
+import { createErrorBag } from "@holo-js/validation";
+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 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 response = await submitter({
+          action: options.action,
+          method: options.method ?? "POST",
+          values: state.values,
+          formData: buildFormData(state.values)
+        });
+        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
+};

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+import { SchemaInputShape, ValidationSchema, InferSchemaData, ValidationErrorBag, FormLikeValidationInput } from '@holo-js/validation';
+export { ErrorTree, ErrorTreeNode, FieldDefinition, FieldRule, InferSchemaData, StandardSchemaV1, StandardSchemaV1Issue, StandardSchemaV1Props, StandardSchemaV1Result, ValidationErrorBag, ValidationFailure, ValidationResult, ValidationSchema, ValidationSuccess, WebFileLike, createErrorBag, defineSchema, field, parse, safeParse } from '@holo-js/validation';
+
+interface FormSchema<TShape extends SchemaInputShape = SchemaInputShape> extends ValidationSchema<TShape> {
+    readonly mode: 'form';
+    readonly $values?: Partial<InferSchemaData<TShape>>;
+}
+interface FormFailurePayload<TData> {
+    readonly ok: false;
+    readonly status: number;
+    readonly valid: false;
+    readonly values: Partial<TData>;
+    readonly errors: Record<string, readonly string[]>;
+}
+interface FormSuccessPayload<TPayload = undefined> {
+    readonly ok: true;
+    readonly status: number;
+    readonly data: TPayload;
+}
+interface SerializedFormSubmission<TData> {
+    readonly valid: boolean;
+    readonly submitted: true;
+    readonly values: Partial<TData> | TData;
+    readonly errors: Record<string, readonly string[]>;
+}
+interface FormSubmissionSuccess<TData> {
+    readonly valid: true;
+    readonly submitted: true;
+    readonly data: TData;
+    readonly values: TData;
+    readonly errors: ValidationErrorBag<TData>;
+    serialize(): SerializedFormSubmission<TData>;
+    success(): FormSuccessPayload<undefined>;
+    success<TPayload>(payload: TPayload, status?: number): FormSuccessPayload<TPayload>;
+    fail(status?: number): FormFailurePayload<TData>;
+}
+interface FormSubmissionFailure<TData> {
+    readonly valid: false;
+    readonly submitted: true;
+    readonly data?: undefined;
+    readonly values: Partial<TData>;
+    readonly errors: ValidationErrorBag<TData>;
+    serialize(): SerializedFormSubmission<TData>;
+    success(): FormSuccessPayload<undefined>;
+    success<TPayload>(payload: TPayload, status?: number): FormSuccessPayload<TPayload>;
+    fail(status?: number): FormFailurePayload<TData>;
+}
+type FormSubmissionResult<TData> = FormSubmissionSuccess<TData> | FormSubmissionFailure<TData>;
+declare class FormContractError extends Error {
+    constructor(message: string);
+}
+declare function schema<TShape extends SchemaInputShape>(shapeOrSchema: TShape | ValidationSchema<TShape>): FormSchema<TShape>;
+declare function isFormSchema(value: unknown): value is FormSchema;
+declare function normalizeStatus(value: number | undefined, fallback: number): number;
+declare function serializeSubmissionState<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>): SerializedFormSubmission<TData>;
+declare function createSubmission<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>): FormSubmissionResult<TData>;
+declare function createSuccessfulSubmission<TShape extends SchemaInputShape, TSchema extends FormSchema<TShape>>(schemaDefinition: TSchema, data: InferSchemaData<TShape>): FormSubmissionSuccess<InferSchemaData<TShape>>;
+declare function createFailedSubmission<TShape extends SchemaInputShape, TSchema extends FormSchema<TShape>>(schemaDefinition: TSchema, values: Partial<InferSchemaData<TShape>>, flattenedErrors: Record<string, readonly string[]>): FormSubmissionFailure<InferSchemaData<TShape>>;
+declare function validate<TShape extends SchemaInputShape, TSchema extends FormSchema<TShape>>(input: FormLikeValidationInput, schemaDefinition: TSchema): Promise<FormSubmissionResult<InferSchemaData<TShape>>>;
+declare const formsInternals: {
+    createSubmission: typeof createSubmission;
+    normalizeStatus: typeof normalizeStatus;
+    serializeSubmissionState: typeof serializeSubmissionState;
+};
+
+export { FormContractError, type FormFailurePayload, type FormSchema, type FormSubmissionFailure, type FormSubmissionResult, type FormSubmissionSuccess, type FormSuccessPayload, type SerializedFormSubmission, createFailedSubmission, createSuccessfulSubmission, formsInternals, isFormSchema, schema, validate };

package/dist/index.mjs

@@ -0,0 +1,32 @@
+import {
+  FormContractError,
+  createFailedSubmission,
+  createSuccessfulSubmission,
+  formsInternals,
+  isFormSchema,
+  schema,
+  validate
+} from "./chunk-Z6TEFT7S.mjs";
+
+// src/index.ts
+import {
+  createErrorBag,
+  defineSchema,
+  field,
+  parse,
+  safeParse
+} from "@holo-js/validation";
+export {
+  FormContractError,
+  createErrorBag,
+  createFailedSubmission,
+  createSuccessfulSubmission,
+  defineSchema,
+  field,
+  formsInternals,
+  isFormSchema,
+  parse,
+  safeParse,
+  schema,
+  validate
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@holo-js/forms",
+  "version": "0.1.0",
+  "description": "Holo-JS Framework - forms-first validation and submission contracts",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.mjs",
+      "default": "./dist/client.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "stub": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "@holo-js/validation": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "tsup": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  }
+}