@krizaka/ui 3.0.0 → 3.2.0

package/dist/form/server.js

@@ -0,0 +1,82 @@
+// src/form/errors.ts
+var KEY = /^[\w-]+(\.[\w-]+)+$/;
+function pathName(path) {
+  let name = "";
+  for (const part of path ?? []) {
+    const key = typeof part === "object" && part !== null ? part.key : part;
+    if (typeof key === "number") name += `[${key}]`;
+    else name += name ? `.${String(key)}` : String(key);
+  }
+  return name;
+}
+var num = (value) => value === void 0 ? void 0 : Number(value);
+function issueError(issue, prefix = "form.errors") {
+  if (KEY.test(issue.message)) return { key: issue.message };
+  const key = (code, values) => ({ key: `${prefix}.${code}`, ...values ? { values } : {} });
+  const collection = issue.origin === "array" || issue.origin === "set";
+  switch (issue.code) {
+    case "invalid_type":
+      return issue.input === void 0 || issue.input === null || issue.input === "" ? key("required") : issue.expected === "number" ? key("invalidNumber") : issue.expected === "date" ? key("invalidDate") : key("invalid");
+    case "too_small": {
+      const minimum = num(issue.minimum);
+      if (issue.origin === "string") return minimum <= 1 ? key("required") : key("tooShort", { minimum });
+      if (collection) return minimum <= 1 ? key("required") : key("tooFew", { minimum });
+      return key("tooSmall", { minimum });
+    }
+    case "too_big": {
+      const maximum = num(issue.maximum);
+      return issue.origin === "string" ? key("tooLong", { maximum }) : collection ? key("tooMany", { maximum }) : key("tooBig", { maximum });
+    }
+    case "invalid_format":
+      if (issue.format === "email") return key("invalidEmail");
+      if (issue.format === "url") return key("invalidUrl");
+      if (issue.format === "date" || issue.format === "datetime") return key("invalidDate");
+      return key("invalidFormat");
+    case "invalid_value":
+      return issue.input === false || issue.input === void 0 ? key("required") : key("invalidChoice");
+    case "invalid_union":
+    case "invalid_key":
+    case "invalid_element":
+      return key("invalidChoice");
+    default:
+      return key("invalid");
+  }
+}
+function issuesToFields(issues, prefix) {
+  const fields = {};
+  for (const issue of issues) {
+    const name = pathName(issue.path);
+    if (!(name in fields)) fields[name] = { ...issueError(issue, prefix), source: "schema" };
+  }
+  return fields;
+}
+
+// src/form/server.ts
+async function validateForm(schema, input, options = {}) {
+  const result = await schema["~standard"].validate(input);
+  if (!result.issues?.length) return { ok: true, value: result.value };
+  const fields = issuesToFields(result.issues, options.prefix);
+  const general = fields[""];
+  delete fields[""];
+  return { ok: false, problem: { status: 422, code: general ? general.key : "validation-failed", fields } };
+}
+function formProblem(error) {
+  if (error && typeof error === "object") {
+    const e = error;
+    if (typeof e.status === "number" || typeof e.code === "string") {
+      return {
+        ...typeof e.status === "number" ? { status: e.status } : {},
+        ...typeof e.code === "string" ? { code: e.code } : {},
+        ...typeof e.detail === "string" ? { detail: e.detail } : {},
+        ...e.fields && typeof e.fields === "object" ? { fields: JSON.parse(JSON.stringify(e.fields)) } : {},
+        ...typeof e.retryAt === "number" ? { retryAt: e.retryAt } : {}
+      };
+    }
+  }
+  return { status: 500, code: "server" };
+}
+export {
+  formProblem,
+  validateForm
+};
+//# sourceMappingURL=server.js.map

package/dist/form/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/form/errors.ts","../../src/form/server.ts"],"sourcesContent":["// Platform-neutral and server-safe: no React, no DOM, no React Native. The errors of a Krizaka form — a schema's issues,\n// a server's Problem Details, an availability check — as one shape, `FormFieldError`, whose words come from a key of the\n// app's catalogue (`form.errors.tooShort`), never from the validation engine's English.\n\n/** A value a message placeholder takes (`{minimum}`, `{suggestion}`). */\nexport type FormMessageValue = string | number;\n\n/** An error of a field or of the whole form: the key of its words in the app's catalogue, and what fills them in. */\nexport interface FormFieldError {\n  /** The i18n key: `form.errors.required`, or the key a schema names (`z.string().min(3, \"signUp.username.short\")`). */\n  key: string;\n  /** The placeholders of the message (`{ minimum: 3 }`). */\n  values?: Readonly<Record<string, FormMessageValue>>;\n  /** The server's own words, in English: shown only when the catalogue has no message for the key. */\n  message?: string;\n  /** A value to offer instead (a free username): a button under the error sets it. Its label is passed translated. */\n  suggestion?: { readonly label: string; readonly value: unknown };\n  /** Shown at once, while the person types (an availability check), not only once they leave the field. */\n  immediate?: boolean;\n  /** Where it comes from: the schema (default), a field's check, or the server's answer (kept until the field changes). */\n  source?: \"schema\" | \"check\" | \"server\";\n}\n\n/** The English defaults of the generic errors, by code — the words a form shows when the app's catalogue has none. */\nexport const formMessages: Readonly<Record<string, string>> = {\n  required: \"This field is required.\",\n  tooShort: \"Use at least {minimum} characters.\",\n  tooLong: \"Use at most {maximum} characters.\",\n  tooSmall: \"Enter {minimum} or more.\",\n  tooBig: \"Enter {maximum} or less.\",\n  tooFew: \"Choose at least {minimum}.\",\n  tooMany: \"Choose at most {maximum}.\",\n  invalidEmail: \"Enter an e-mail address, like name@example.com.\",\n  invalidUrl: \"Enter a web address, like https://example.com.\",\n  invalidDate: \"Enter a real date.\",\n  invalidNumber: \"Enter a number.\",\n  invalidFormat: \"Check the format of this field.\",\n  invalidChoice: \"Choose one of the options.\",\n  invalid: \"Check this field.\",\n  // The whole form (a server's answer without fields): the codes of @krizaka/query's KrizakaApiError.\n  network: \"No connection. Check your network and try again.\",\n  \"rate-limited\": \"Too many tries. Wait a moment and try again.\",\n  unauthorized: \"Your session has ended. Sign in again.\",\n  forbidden: \"You are not allowed to do this.\",\n  conflict: \"This was changed meanwhile. Reload and try again.\",\n  \"validation-failed\": \"Some fields need your attention.\",\n  unavailable: \"The service is unavailable for a moment. Try again shortly.\",\n  server: \"Something went wrong on our side. Try again.\",\n};\n\n/** How a form finds its words: the app's translate function, and the prefixes of its keys. */\nexport interface FormI18n {\n  /** The app's translate function (`(key, values) => t(key, values)`): a string, or `undefined` when the key is missing. */\n  t?: (key: string, values?: Readonly<Record<string, FormMessageValue>>) => string | undefined;\n  /** The prefix of the generic field errors. Default `form.errors` (→ `form.errors.tooShort`). */\n  prefix?: string;\n  /** The prefix of the server's codes for the whole form, as `KrizakaApiError.messageKey()`. Default `apiErrors`. */\n  apiPrefix?: string;\n  /** The locale of numbers, money and dates. Default `en`. */\n  locale?: string;\n}\n\nconst KEY = /^[\\w-]+(\\.[\\w-]+)+$/;\n\nconst fill = (text: string, values?: Readonly<Record<string, FormMessageValue>>) =>\n  values ? text.replace(/\\{(\\w+)\\}/g, (all, name: string) => (values[name] === undefined ? all : String(values[name]))) : text;\n\n/** The words of an error: the app's catalogue, else the English default of its code, else the server's words, else the key. */\nexport function formMessage(error: FormFieldError | string, i18n: FormI18n = {}): string {\n  const e = typeof error === \"string\" ? { key: error } : error;\n  const translated = i18n.t?.(e.key, e.values);\n  if (translated && translated !== e.key) return translated;\n  const code = e.key.slice(e.key.lastIndexOf(\".\") + 1);\n  const fallback = formMessages[code];\n  // The server's words beat a generic default (a refusal without a code), never a default for its own code.\n  if (e.message && (code === \"invalid\" || !fallback)) return e.message;\n  if (fallback && (e.key.startsWith(`${i18n.prefix ?? \"form.errors\"}.`) || e.key.startsWith(`${i18n.apiPrefix ?? \"apiErrors\"}.`))) return fill(fallback, e.values);\n  return e.message ?? (KEY.test(e.key) ? fill(fallback ?? formMessages.invalid!, e.values) : e.key);\n}\n\n/** One issue of a Standard Schema (zod 4, valibot, arktype): zod adds its `code` and limits, read when present. */\nexport interface SchemaIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n  readonly code?: string;\n  readonly minimum?: number | bigint;\n  readonly maximum?: number | bigint;\n  readonly origin?: string;\n  readonly format?: string;\n  readonly input?: unknown;\n  readonly expected?: string;\n}\n\n/** A field's name from an issue's path, as the form writes it: `links[0].url`. */\nexport function pathName(path: SchemaIssue[\"path\"]): string {\n  let name = \"\";\n  for (const part of path ?? []) {\n    const key = typeof part === \"object\" && part !== null ? part.key : part;\n    if (typeof key === \"number\") name += `[${key}]`;\n    else name += name ? `.${String(key)}` : String(key);\n  }\n  return name;\n}\n\nconst num = (value: number | bigint | undefined) => (value === undefined ? undefined : Number(value));\n\n/** The key and values of an issue: the schema's own key when it names one, else the generic code of what failed. */\nexport function issueError(issue: SchemaIssue, prefix = \"form.errors\"): FormFieldError {\n  if (KEY.test(issue.message)) return { key: issue.message };\n  const key = (code: string, values?: Record<string, FormMessageValue>) => ({ key: `${prefix}.${code}`, ...(values ? { values } : {}) });\n  const collection = issue.origin === \"array\" || issue.origin === \"set\";\n  switch (issue.code) {\n    case \"invalid_type\":\n      return issue.input === undefined || issue.input === null || issue.input === \"\" ? key(\"required\") : issue.expected === \"number\" ? key(\"invalidNumber\") : issue.expected === \"date\" ? key(\"invalidDate\") : key(\"invalid\");\n    case \"too_small\": {\n      const minimum = num(issue.minimum)!;\n      if (issue.origin === \"string\") return minimum <= 1 ? key(\"required\") : key(\"tooShort\", { minimum });\n      if (collection) return minimum <= 1 ? key(\"required\") : key(\"tooFew\", { minimum });\n      return key(\"tooSmall\", { minimum });\n    }\n    case \"too_big\": {\n      const maximum = num(issue.maximum)!;\n      return issue.origin === \"string\" ? key(\"tooLong\", { maximum }) : collection ? key(\"tooMany\", { maximum }) : key(\"tooBig\", { maximum });\n    }\n    case \"invalid_format\":\n      if (issue.format === \"email\") return key(\"invalidEmail\");\n      if (issue.format === \"url\") return key(\"invalidUrl\");\n      if (issue.format === \"date\" || issue.format === \"datetime\") return key(\"invalidDate\");\n      return key(\"invalidFormat\");\n    case \"invalid_value\":\n      // `z.literal(true)`: a box that must be ticked.\n      return issue.input === false || issue.input === undefined ? key(\"required\") : key(\"invalidChoice\");\n    case \"invalid_union\":\n    case \"invalid_key\":\n    case \"invalid_element\":\n      return key(\"invalidChoice\");\n    default:\n      return key(\"invalid\");\n  }\n}\n\n/** The first error of each field of a schema's issues (an issue without a path is the whole form's: `\"\"`). */\nexport function issuesToFields(issues: readonly SchemaIssue[], prefix?: string): Record<string, FormFieldError> {\n  const fields: Record<string, FormFieldError> = {};\n  for (const issue of issues) {\n    const name = pathName(issue.path);\n    if (!(name in fields)) fields[name] = { ...issueError(issue, prefix), source: \"schema\" };\n  }\n  return fields;\n}\n\n/**\n * A refusal the form shows, serialisable (a Server Action returns it): the shape of `KrizakaApiError` of @krizaka/query —\n * a `KrizakaApiError` *is* a `FormProblem`. `fields` go under their fields, the rest above the submit button.\n */\nexport interface FormProblem {\n  /** The HTTP status (0 when no response arrived). */\n  status?: number;\n  /** The stable code of the refusal (`rate-limited`, `conflict`, `ACCOUNT_EXISTS`): the key of its words. */\n  code?: string;\n  /** The server's sentence, in English: shown only when the catalogue has no message for the code. */\n  detail?: string;\n  /** The refused fields, by name: a server's `{ code, message }`, or an error the form already knows (`key`). */\n  fields?: Readonly<Record<string, { code?: string; message: string } | FormFieldError | string>>;\n  /** Epoch ms before which the same call is refused (a 429). */\n  retryAt?: number;\n}\n\n/** True for what a form can read as a problem: a `KrizakaApiError`, a `FormProblem`, an `{ ok: false, problem }` result. */\nexport function isFormProblem(value: unknown): value is FormProblem {\n  return typeof value === \"object\" && value !== null && (\"fields\" in value || \"code\" in value || \"status\" in value);\n}\n\n/** A problem as field errors (by name) and the whole form's error (or `null` when every refusal has its field). */\nexport function problemToErrors(\n  problem: FormProblem,\n  i18n: FormI18n = {},\n  known?: (name: string) => boolean,\n  codeFields: Readonly<Record<string, string>> = {},\n): { fields: Record<string, FormFieldError>; form: FormFieldError | null } {\n  const prefix = i18n.prefix ?? \"form.errors\";\n  const fields: Record<string, FormFieldError> = {};\n  let unplaced = false;\n  // A refusal named by a code that belongs to a field (`UNDERAGE` → `dateOfBirth`): under that field, in its words.\n  const owner = problem.code ? codeFields[problem.code] : undefined;\n  if (owner && (!known || known(owner)) && !problem.fields?.[owner]) {\n    fields[owner] = { key: `${prefix}.${problem.code}`, ...(problem.detail ? { message: problem.detail } : {}), source: \"server\" };\n    if (!problem.fields || Object.keys(problem.fields).length === 0) return { fields, form: null };\n  }\n  for (const [name, refusal] of Object.entries(problem.fields ?? {})) {\n    if (known && !known(name)) {\n      unplaced = true;\n      continue;\n    }\n    const error: FormFieldError =\n      typeof refusal === \"string\"\n        ? { key: refusal }\n        : \"key\" in refusal\n          ? refusal\n          : { key: refusal.code ? (KEY.test(refusal.code) ? refusal.code : `${prefix}.${refusal.code}`) : `${prefix}.invalid`, message: refusal.message };\n    fields[name] = { ...error, source: \"server\" };\n  }\n  const placed = Object.keys(fields).length > 0;\n  if (placed && !unplaced) return { fields, form: null };\n  const code = problem.code ?? (problem.status === 0 ? \"network\" : problem.status && problem.status >= 500 ? \"server\" : \"invalid\");\n  const retryIn = problem.retryAt ? Math.max(1, Math.ceil((problem.retryAt - Date.now()) / 1000)) : undefined;\n  return {\n    fields,\n    form: { key: KEY.test(code) ? code : `${i18n.apiPrefix ?? \"apiErrors\"}.${code}`, ...(problem.detail ? { message: problem.detail } : {}), ...(retryIn ? { values: { seconds: retryIn } } : {}), source: \"server\" },\n  };\n}\n","/**\n * @krizaka/ui/form/server — the server side of a Krizaka form, for a Server Action or a route handler (no \"use client\",\n * no React): `validateForm` parses with the form's own schema and answers the errors with the same keys the form shows,\n * `formProblem` turns a thrown error (a `KrizakaApiError` of @krizaka/query) into the serialisable refusal a form reads.\n */\nimport { type FormFieldError, type FormProblem, issuesToFields, type SchemaIssue } from \"./errors\";\n\nexport type { FormFieldError, FormProblem } from \"./errors\";\n\n/** What a Server Action answers a form: done (with what it made), or a refusal (`fields` under their fields). */\nexport type FormActionResult<T = unknown> = { ok: true; data?: T } | { ok: false; problem: FormProblem };\n\ntype Schema<O> = { readonly \"~standard\": { validate: (value: unknown) => { value?: O; issues?: readonly SchemaIssue[] } | Promise<{ value?: O; issues?: readonly SchemaIssue[] }> } };\n\n/**\n * Parses what a form sent with its schema (never trust the client): the value, or a `validation-failed` problem whose\n * fields carry the keys the form would show (`form.errors.tooShort`, the schema's own keys).\n */\nexport async function validateForm<O>(schema: Schema<O>, input: unknown, options: { prefix?: string } = {}): Promise<{ ok: true; value: O } | { ok: false; problem: FormProblem }> {\n  const result = await schema[\"~standard\"].validate(input);\n  if (!result.issues?.length) return { ok: true, value: result.value as O };\n  const fields: Record<string, FormFieldError> = issuesToFields(result.issues, options.prefix);\n  const general = fields[\"\"];\n  delete fields[\"\"];\n  return { ok: false, problem: { status: 422, code: general ? general.key : \"validation-failed\", fields } };\n}\n\n/** A thrown error as a refusal a form reads — a `KrizakaApiError` keeps its status, code, fields and retry time. */\nexport function formProblem(error: unknown): FormProblem {\n  if (error && typeof error === \"object\") {\n    const e = error as { status?: unknown; code?: unknown; detail?: unknown; fields?: unknown; retryAt?: unknown };\n    if (typeof e.status === \"number\" || typeof e.code === \"string\") {\n      return {\n        ...(typeof e.status === \"number\" ? { status: e.status } : {}),\n        ...(typeof e.code === \"string\" ? { code: e.code } : {}),\n        ...(typeof e.detail === \"string\" ? { detail: e.detail } : {}),\n        ...(e.fields && typeof e.fields === \"object\" ? { fields: JSON.parse(JSON.stringify(e.fields)) as FormProblem[\"fields\"] } : {}),\n        ...(typeof e.retryAt === \"number\" ? { retryAt: e.retryAt } : {}),\n      };\n    }\n  }\n  return { status: 500, code: \"server\" };\n}\n"],"mappings":"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","names":[]}

package/dist/form.d.ts

@@ -0,0 +1,503 @@
+import { DeepKeys, AnyFormApi, AnyFieldApi, StandardSchemaV1 } from '@tanstack/react-form';
+import * as React from 'react';
+import { ButtonProps } from '@krizaka/ui/button';
+import { ComboboxOption, ComboboxLabels } from '@krizaka/ui/combobox';
+import { DatePickerLabels } from '@krizaka/ui/date-picker';
+import { Dropzone } from '@krizaka/ui/file-upload';
+import { TagInputProps } from '@krizaka/ui/tag-input';
+
+/** A part of a typed date. */
+type DatePart = "day" | "month" | "year";
+/** The order of day, month and year in a locale (`en-US` → month, day, year; `fr` → day, month, year). */
+declare function datePartsOrder(locale: string): DatePart[];
+/** The ISO-ordered value of what was typed: `""` when nothing is, `YYYY-MM-DD` otherwise (not necessarily a real date). */
+declare function composeDate(parts: Readonly<Record<DatePart, string>>): string;
+/** True for a real calendar date written `YYYY-MM-DD` (not `2001-02-30`). */
+declare function isRealDate(value: string): boolean;
+/** The latest date of birth of someone `age` years old today (`YYYY-MM-DD`): an age gate's `max`, `value <= latestBirthDate(18)`. */
+declare function latestBirthDate(age: number, today?: Date): string;
+
+/** A value a message placeholder takes (`{minimum}`, `{suggestion}`). */
+type FormMessageValue = string | number;
+/** An error of a field or of the whole form: the key of its words in the app's catalogue, and what fills them in. */
+interface FormFieldError {
+    /** The i18n key: `form.errors.required`, or the key a schema names (`z.string().min(3, "signUp.username.short")`). */
+    key: string;
+    /** The placeholders of the message (`{ minimum: 3 }`). */
+    values?: Readonly<Record<string, FormMessageValue>>;
+    /** The server's own words, in English: shown only when the catalogue has no message for the key. */
+    message?: string;
+    /** A value to offer instead (a free username): a button under the error sets it. Its label is passed translated. */
+    suggestion?: {
+        readonly label: string;
+        readonly value: unknown;
+    };
+    /** Shown at once, while the person types (an availability check), not only once they leave the field. */
+    immediate?: boolean;
+    /** Where it comes from: the schema (default), a field's check, or the server's answer (kept until the field changes). */
+    source?: "schema" | "check" | "server";
+}
+/** The English defaults of the generic errors, by code — the words a form shows when the app's catalogue has none. */
+declare const formMessages: Readonly<Record<string, string>>;
+/** How a form finds its words: the app's translate function, and the prefixes of its keys. */
+interface FormI18n {
+    /** The app's translate function (`(key, values) => t(key, values)`): a string, or `undefined` when the key is missing. */
+    t?: (key: string, values?: Readonly<Record<string, FormMessageValue>>) => string | undefined;
+    /** The prefix of the generic field errors. Default `form.errors` (→ `form.errors.tooShort`). */
+    prefix?: string;
+    /** The prefix of the server's codes for the whole form, as `KrizakaApiError.messageKey()`. Default `apiErrors`. */
+    apiPrefix?: string;
+    /** The locale of numbers, money and dates. Default `en`. */
+    locale?: string;
+}
+/** The words of an error: the app's catalogue, else the English default of its code, else the server's words, else the key. */
+declare function formMessage(error: FormFieldError | string, i18n?: FormI18n): string;
+/** One issue of a Standard Schema (zod 4, valibot, arktype): zod adds its `code` and limits, read when present. */
+interface SchemaIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }>;
+    readonly code?: string;
+    readonly minimum?: number | bigint;
+    readonly maximum?: number | bigint;
+    readonly origin?: string;
+    readonly format?: string;
+    readonly input?: unknown;
+    readonly expected?: string;
+}
+/** The key and values of an issue: the schema's own key when it names one, else the generic code of what failed. */
+declare function issueError(issue: SchemaIssue, prefix?: string): FormFieldError;
+/** The first error of each field of a schema's issues (an issue without a path is the whole form's: `""`). */
+declare function issuesToFields(issues: readonly SchemaIssue[], prefix?: string): Record<string, FormFieldError>;
+/**
+ * A refusal the form shows, serialisable (a Server Action returns it): the shape of `KrizakaApiError` of @krizaka/query —
+ * a `KrizakaApiError` *is* a `FormProblem`. `fields` go under their fields, the rest above the submit button.
+ */
+interface FormProblem {
+    /** The HTTP status (0 when no response arrived). */
+    status?: number;
+    /** The stable code of the refusal (`rate-limited`, `conflict`, `ACCOUNT_EXISTS`): the key of its words. */
+    code?: string;
+    /** The server's sentence, in English: shown only when the catalogue has no message for the code. */
+    detail?: string;
+    /** The refused fields, by name: a server's `{ code, message }`, or an error the form already knows (`key`). */
+    fields?: Readonly<Record<string, {
+        code?: string;
+        message: string;
+    } | FormFieldError | string>>;
+    /** Epoch ms before which the same call is refused (a 429). */
+    retryAt?: number;
+}
+/** A problem as field errors (by name) and the whole form's error (or `null` when every refusal has its field). */
+declare function problemToErrors(problem: FormProblem, i18n?: FormI18n, known?: (name: string) => boolean, codeFields?: Readonly<Record<string, string>>): {
+    fields: Record<string, FormFieldError>;
+    form: FormFieldError | null;
+};
+
+/** A schema the form validates with: any Standard Schema — zod 4 (`z.object`), valibot, arktype. */
+type FormSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output>;
+/** The values a form holds: the schema's input. */
+type FormValues<S> = S extends {
+    readonly "~standard": {
+        readonly types?: {
+            readonly input: infer I;
+        };
+    };
+} ? I : never;
+/** The values a form sends: the schema's output (zod transforms applied). */
+type FormOutput<S> = S extends {
+    readonly "~standard": {
+        readonly types?: {
+            readonly output: infer O;
+        };
+    };
+} ? O : never;
+/** A field's name: `email`, `address.city`, `links[0].url`. */
+type FieldName<V> = DeepKeys<V> & string;
+/** What a Server Action (or any submit) answers: done, or a refusal the form shows. */
+type FormActionResult<T = unknown> = {
+    ok: true;
+    data?: T;
+} | {
+    ok: false;
+    problem: FormProblem;
+};
+/** A value checked on the server as it is typed: an error (or its key), or nothing when the value is fine. */
+type FieldCheck<T = unknown> = (value: T, signal: AbortSignal) => Promise<FormFieldError | string | null | undefined> | FormFieldError | string | null | undefined;
+interface KrizakaFormDefinition<S extends FormSchema> {
+    /** The schema of the values (zod 4): the same one the server parses with. */
+    schema: S;
+    /** The values at first: every field of the schema. */
+    defaultValues: FormValues<S>;
+    /** The words: the app's translate function, the key prefixes, the locale. */
+    i18n?: FormI18n;
+}
+interface UseKrizakaFormOptions<S extends FormSchema, R = unknown> {
+    /** Sends the values (the schema's output): a mutation of @krizaka/query, a Server Action. Throw a `KrizakaApiError` or
+     * return `{ ok: false, problem }` to refuse: its `fields` go under their fields, the rest above the button. */
+    onSubmit?: (values: FormOutput<S>) => R | Promise<R>;
+    /** Called after a successful submit with what `onSubmit` returned (`data` of a `{ ok: true, data }`). */
+    onSuccess?: (result: R extends FormActionResult<infer T> ? T | undefined : R) => void;
+    /** Values that replace the definition's (a profile loaded from the server). */
+    defaultValues?: FormValues<S>;
+    /** Overrides the definition's words (the translate function of a hook). */
+    i18n?: FormI18n;
+    /** The server's codes that belong to a field (`{ UNDERAGE: "dateOfBirth", USERNAME_RESERVED: "username" }`): a refusal
+     * with that code shows under the field, as `form.errors.<CODE>`, instead of above the button. */
+    codeFields?: Readonly<Record<string, string>>;
+}
+/** The state of a form, for its fields and its button. */
+interface FormContextValue {
+    /** TanStack's form, through the facade: never import @tanstack/* in a product. */
+    readonly api: AnyFormApi;
+    readonly i18n: FormI18n;
+    /** The whole form's error (a refusal without a field), or null. */
+    readonly error: FormFieldError | null;
+    /** Sends the form: validates, focuses (web) or announces (native) the first error, else calls `onSubmit`. */
+    readonly submit: () => Promise<boolean>;
+}
+/** The form around a field: inside `form.Form`. */
+declare function useFormContext(): FormContextValue;
+interface FieldOptions<T> {
+    /** Checks the value on the server as it is typed (a username's availability): debounced, aborted when it changes. */
+    validateAsync?: FieldCheck<T>;
+    /** The wait, in ms, between the last change and `validateAsync`. Default 350. */
+    asyncDebounceMs?: number;
+}
+/** A field as its component draws it: the value, its setter, its error in words, its state. */
+interface KrizakaField<T = unknown> {
+    /** The id of the control (`htmlFor` of its label). */
+    readonly id: string;
+    readonly name: string;
+    readonly value: T;
+    /** Sets the value (clears a refusal of the server on it). */
+    setValue(value: T): void;
+    /** Call when the control loses focus: from then on, its errors show. */
+    readonly onBlur: () => void;
+    /** The error to show, in words — only once it should show. */
+    readonly error: string | undefined;
+    /** The error itself, with its suggestion. */
+    readonly errorDetail: FormFieldError | undefined;
+    /** A check (`validateAsync`) is running. */
+    readonly validating: boolean;
+    /** The check passed for the current value. */
+    readonly available: boolean;
+    /** The ids of the hint and the error (`aria-describedby`). */
+    readonly hintId: string;
+    readonly errorId: string;
+    /** The form's locale (numbers, money, dates). */
+    readonly locale: string;
+    /** TanStack's field, through the facade. */
+    readonly api: AnyFieldApi;
+}
+/** Binds a field of the form around it (inside `form.Form`): what the platform's field components are made of. */
+declare function useKrizakaField<T = unknown>(name: string, options?: FieldOptions<T>): KrizakaField<T>;
+/** The array of a field array, with its operations (`form.FieldArray`). */
+interface KrizakaFieldArray<T = unknown> {
+    readonly name: string;
+    readonly items: readonly T[];
+    /** Adds an item at the end. */
+    readonly push: (item: T) => void;
+    /** Removes the item at `index`. */
+    readonly remove: (index: number) => void;
+    /** Moves an item. */
+    readonly move: (from: number, to: number) => void;
+    /** The name of a sub-field of an item: `name(0, "url")` → `links[0].url`. */
+    readonly fieldName: (index: number, key?: string) => string;
+    /** The error of the array itself (too few, too many), in words, once it should show. */
+    readonly error: string | undefined;
+}
+/** Binds an array of the form (a list of links, of tiers): its items and their operations. */
+declare function useKrizakaFieldArray<T = unknown>(name: string): KrizakaFieldArray<T>;
+/** The value of a field, kept up to date (`form.Watch`): show a part of the form only when a box is ticked. */
+declare function useFormValue<T = unknown>(name: string): T;
+/** The state of the submit, for a button: sending, and whether the last try succeeded. */
+declare function useFormStatus(): {
+    submitting: boolean;
+    succeeded: boolean;
+    attempts: number;
+};
+/** The platform's components, typed by the form's field names: `name` completes and is checked against the schema. */
+type BoundFields<C, N extends string> = {
+    [K in keyof C]: C[K] extends (props: infer P) => infer R ? (P extends {
+        name: string;
+    } ? (props: Omit<P, "name"> & {
+        name: N;
+    }) => R : C[K]) : C[K];
+};
+/** A form in a component: its fields (typed by the schema), its submit and its state. */
+type KrizakaFormInstance<S extends FormSchema, C, RootProps> = BoundFields<C, FieldName<FormValues<S>>> & {
+    /** The form element (web) or view (native): renders its fields and provides them the form. */
+    Form: (props: RootProps) => React.ReactElement;
+    /** Sends the form (what `Submit` does): `true` when it went through. */
+    submit: () => Promise<boolean>;
+    /** Back to the default values (or the given ones), errors cleared. */
+    reset: (values?: FormValues<S>) => void;
+    /** Sets a field's value from outside (a suggestion, a preset). */
+    setValue: (name: FieldName<FormValues<S>>, value: unknown) => void;
+    /** The values now. */
+    getValues: () => FormValues<S>;
+    /** The whole form's error (a refusal without a field), or null. */
+    error: FormFieldError | null;
+    /** TanStack's form, the escape hatch — never import @tanstack/* in a product. */
+    api: AnyFormApi;
+};
+/** A form defined once (schema + defaults), used in components: `signUp.useForm({ onSubmit })`. */
+interface KrizakaFormFactory<S extends FormSchema, C, RootProps> {
+    readonly schema: S;
+    readonly defaultValues: FormValues<S>;
+    /** The form in a component: `onSubmit` sends the values (a mutation), a thrown `KrizakaApiError` lands on the fields. */
+    useForm<R = unknown>(options?: UseKrizakaFormOptions<S, R>): KrizakaFormInstance<S, C, RootProps>;
+    /** The form sent by a Server Action: it receives the values and answers `{ ok: true, data }` or `{ ok: false, problem }`. */
+    useFormWithAction<T = unknown>(action: (values: FormOutput<S>) => Promise<FormActionResult<T>>, options?: Omit<UseKrizakaFormOptions<S, FormActionResult<T>>, "onSubmit">): KrizakaFormInstance<S, C, RootProps>;
+}
+
+/** The currency's sign in a locale (`USD`, `en-US` → `$`; `EUR`, `fr` → `€`). */
+declare function currencySymbol(currency: string, locale: string): string;
+/**
+ * An amount as typed (`12.5`, `12,50`, `1,234.56`, `1 234,56`) → integer minor units (`1250`). `undefined` when empty,
+ * `null` when it is not an amount (letters, more decimals than the currency has).
+ */
+declare function parseMoney(text: string, currency: string, locale?: string): number | null | undefined;
+/** Minor units as the field writes them while editing (`1250`, `USD`, `fr` → `12,50`): no symbol, no grouping. */
+declare function moneyInputText(minorUnits: number | null | undefined, currency: string, locale?: string): string;
+
+type Base = {
+    /** The field's name in the schema: `email`, `address.city`, `links[0].url` (typed by the form). */
+    name: string;
+    /** The visible label, passed translated (also the control's accessible name). */
+    label: string;
+    /** A help text under the control, read with it; the error takes its place when there is one. */
+    hint?: string;
+    /** Not available. */
+    disabled?: boolean;
+    /** Classes merged on the field's root. */
+    className?: string;
+};
+type FormProps = Omit<React.ComponentProps<"form">, "onSubmit" | "noValidate"> & {
+    /** The fields, the error and the button. */
+    children?: React.ReactNode;
+};
+type SubmitProps = Omit<ButtonProps, "type" | "loading"> & {
+    /** The button's words, passed translated ("Create my account"). */
+    children: React.ReactNode;
+};
+/** The submit button: busy while the form is sent (not pressable twice), never disabled for an invalid form. */
+declare function Submit({ variant, children, ...props }: SubmitProps): React.JSX.Element;
+type FormErrorProps = {
+    /** A headline above the message ("We could not create your account"), passed translated. */
+    title?: string;
+    /** Classes merged on the alert. */
+    className?: string;
+};
+/** The whole form's error — a refusal of the server that belongs to no field (a conflict, too many tries, no network). */
+declare function FormError({ title, className }: FormErrorProps): React.JSX.Element | null;
+type TextFieldProps = Base & {
+    /** `text` (default), `email`, `password`, `url`, `tel`, `search`: the right keyboard on a phone. */
+    type?: "text" | "email" | "password" | "url" | "tel" | "search";
+    /** The browser's autofill (`email`, `username`, `new-password`, `name`). */
+    autoComplete?: string;
+    /** An example of a value, passed translated — never the label. */
+    placeholder?: string;
+    /** The keyboard on a phone (`numeric`, `decimal`). */
+    inputMode?: React.HTMLAttributes<HTMLInputElement>["inputMode"];
+    /** The most characters. */
+    maxLength?: number;
+    /** Cleans what is typed before it is stored (`(v) => v.toLowerCase().replace(/\s+/g, "_")`). */
+    transform?: (raw: string) => string;
+    /** Checks the value on the server as it is typed (availability): an error key, or nothing when it is fine. */
+    validateAsync?: FieldCheck<string>;
+    /** The wait, in ms, between the last key and `validateAsync`. Default 350. */
+    asyncDebounceMs?: number;
+    /** The words once `validateAsync` accepted the value ("@eric is free"), passed translated. */
+    availableHint?: string;
+    /** The name of the wait while it checks ("Checking"), passed translated. */
+    checkingLabel?: string;
+    /** Something before the text (an `@`, an icon). */
+    start?: React.ReactNode;
+};
+/** A text field of the form: label, input, hint or error, an optional check on the server. */
+declare function TextField({ name, label, hint, disabled, className, type, transform, validateAsync, asyncDebounceMs, availableHint, checkingLabel, start, ...input }: TextFieldProps): React.JSX.Element;
+type TextAreaProps = Base & {
+    /** An example of a value, passed translated. */
+    placeholder?: string;
+    /** The visible lines. Default 4. */
+    rows?: number;
+    /** The most characters. */
+    maxLength?: number;
+};
+/** A longer text of the form (a bio, a description, a report). */
+declare function TextArea({ name, label, hint, disabled, className, rows, ...input }: TextAreaProps): React.JSX.Element;
+type CheckboxProps = Omit<Base, "label"> & {
+    /** The words next to the box, clickable with it — text, or a sentence with links (terms, privacy). */
+    label: React.ReactNode;
+};
+/** A box of the form (`boolean`): terms to accept, an option. */
+declare function Checkbox({ name, label, hint, disabled, className }: CheckboxProps): React.JSX.Element;
+/** An on/off setting of the form (`boolean`): the label and its hint beside the switch. */
+declare function Switch({ name, label, hint, disabled, className }: Base): React.JSX.Element;
+/** A choice of the form: the value stored, its words (passed translated), a line under them. */
+type FormOption = {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+};
+type RadioGroupProps = Base & {
+    /** The choices, all visible (two to five). */
+    options: readonly FormOption[];
+    /** `list` (a dot and its words, default) or `cards` (a whole card is the radio: an amount, a plan, an audience). */
+    variant?: "list" | "cards";
+    /** `vertical` (default) or `horizontal`. */
+    orientation?: "vertical" | "horizontal";
+};
+/** One choice among a few, all visible. */
+declare function RadioGroup({ name, label, hint, disabled, className, options, variant, orientation }: RadioGroupProps): React.JSX.Element;
+type SelectProps = Base & {
+    /** The choices, in the platform's own menu (a country, a category). */
+    options: readonly FormOption[];
+    /** The first line while nothing is chosen ("Choose a category"), passed translated. */
+    placeholder?: string;
+};
+/** One choice among many, in the platform's menu (`<select>`: accessible and right on phones). */
+declare function Select({ name, label, hint, disabled, className, options, placeholder }: SelectProps): React.JSX.Element;
+type ComboboxProps = Base & {
+    /** The options, filtered as the person types. */
+    options?: readonly ComboboxOption[];
+    /** Fetches the options for a query (debounced, aborted by a newer one). */
+    onSearch?: (query: string, signal: AbortSignal) => Promise<readonly ComboboxOption[]>;
+    /** Several values (`string[]`), shown as chips; one (`string`) by default. */
+    multiple?: boolean;
+    /** Offers to create the query as a value. */
+    creatable?: boolean;
+    /** The input's placeholder, passed translated. */
+    placeholder?: string;
+    /** The words of the control, passed translated. */
+    labels?: Partial<ComboboxLabels>;
+};
+/** A choice among many, typed to filter or fetched: one value (`string`) or several (`string[]`). */
+declare function Combobox({ name, label, hint, disabled, className, options, onSearch, multiple, creatable, placeholder, labels }: ComboboxProps): React.JSX.Element;
+type DateFieldProps = Base & {
+    /** `calendar` (default: a date near today — a publication, an appointment) or `parts` (day · month · year typed: a
+     * memorable date, a birth date). */
+    entry?: "calendar" | "parts";
+    /** The earliest date (ISO), for the calendar. */
+    min?: string;
+    /** The latest date (ISO), for the calendar (`latestBirthDate(18)` for an age gate). */
+    max?: string;
+    /** The words of the calendar, or the names of the boxes (`day`, `month`, `year`), passed translated. */
+    labels?: Partial<DatePickerLabels> & Partial<Record<DatePart, string>>;
+    /** `bday` for a date of birth. */
+    autoComplete?: "bday" | "off";
+};
+/** A date of the form (`YYYY-MM-DD`, `""` for none): a calendar, or day · month · year typed in the locale's order. */
+declare function DateField({ name, label, hint, disabled, className, entry, min, max, labels, autoComplete }: DateFieldProps): React.JSX.Element;
+type TagsProps = Base & Pick<TagInputProps, "suggestions" | "normalize" | "max" | "separators" | "placeholder" | "labels">;
+/** Free words of the form as chips (`string[]`): tags, keywords. */
+declare function TagInput({ name, label, hint, disabled, className, ...props }: TagsProps): React.JSX.Element;
+type FileUploadProps = Omit<Base, "hint"> & {
+    /** The title in the zone ("Drop your video here"), passed translated. */
+    title: string;
+    /** The button that opens the file picker, passed translated. */
+    browseLabel: string;
+    /** What is accepted, in words ("MP4 or MOV, up to 4 GB"). */
+    hint?: string;
+    /** The types accepted (`video/*`, `image/png,.pdf`). */
+    accept?: string;
+    /** The largest file, in bytes. */
+    maxSize?: number;
+    /** Several files (`File[]`, up to `maxFiles`); one by default (still a `File[]` of one). */
+    multiple?: boolean;
+    /** The most files. */
+    maxFiles?: number;
+    /** The name of a file's remove button (`(name) => "Remove " + name`), passed translated. */
+    removeLabel: (fileName: string) => string;
+    /** The words of a refused file (`(r) => r.file.name + " is too large"`). */
+    refusalLabel?: React.ComponentProps<typeof Dropzone>["refusalLabel"];
+};
+/** Files of the form (`File[]`): a drop zone, then the chosen files, each removable. */
+declare function FileUpload({ name, label, hint, disabled, className, title, browseLabel, accept, maxSize, multiple, maxFiles, removeLabel, refusalLabel }: FileUploadProps): React.JSX.Element;
+type MoneyProps = Base & {
+    /** The currency (ISO 4217: `USD`, `EUR`, `JPY`): its sign before the amount, its decimals. */
+    currency: string;
+    /** An example of an amount, passed translated. */
+    placeholder?: string;
+};
+/** An amount of the form, stored as integer minor units (cents: `1250` = 12.50), typed the locale's way. */
+declare function Money({ name, label, hint, disabled, className, currency, placeholder }: MoneyProps): React.JSX.Element;
+type SliderProps = Base & {
+    /** The lowest value. Default 0. */
+    min?: number;
+    /** The highest value. Default 100. */
+    max?: number;
+    /** The step. Default 1. */
+    step?: number;
+    /** The value as words ("15 %", "3 min"), shown and read. */
+    formatValue?: (value: number) => string;
+    /** For a range (`[number, number]`): each thumb's name, passed translated. */
+    thumbLabels?: [string, string];
+};
+/** A number (or a range) of the form, chosen by feel: a share, a volume, a price range. */
+declare function Slider({ name, label, hint, disabled, className, min, max, step, formatValue, thumbLabels }: SliderProps): React.JSX.Element;
+type FormFieldProps<T = unknown> = {
+    /** The field's name in the schema (typed by the form). */
+    name: string;
+    /** Checks the value on the server as it changes. */
+    validateAsync?: FieldCheck<T>;
+    /** The wait, in ms, before `validateAsync`. */
+    asyncDebounceMs?: number;
+    /** Draws the field: its value, setter, error and ids (`useKrizakaField`). */
+    children: (field: KrizakaField<T>) => React.ReactNode;
+};
+/** A field drawn by the app (a control the package does not have): the form's value, errors and ids, any markup. */
+declare function FormField({ name, validateAsync, asyncDebounceMs, children }: FormFieldProps): React.JSX.Element;
+type FieldArrayProps<T = unknown> = {
+    /** The array's name in the schema (typed by the form). */
+    name: string;
+    /** Draws the items: `items`, `push`, `remove`, `move`, `fieldName(i, "url")` for the fields of an item. */
+    children: (array: KrizakaFieldArray<T>) => React.ReactNode;
+};
+/** A list of fields that grows and shrinks (links, tiers, guests): each item's fields named `links[0].url`. */
+declare function FieldArray({ name, children }: FieldArrayProps): React.JSX.Element;
+type WatchProps<T = unknown> = {
+    /** The field to follow (typed by the form). */
+    name: string;
+    /** Draws from its current value: show a part of the form only when a box is ticked. */
+    children: (value: T) => React.ReactNode;
+};
+/** Renders from a field's current value (a part shown only when a box is ticked, a total). */
+declare function Watch({ name, children }: WatchProps): React.JSX.Element;
+/**
+ * A form, defined once: its schema (zod 4) and default values — the same schema the server parses with. In a component,
+ * `signUp.useForm({ onSubmit })` gives the form and its fields, typed by the schema: `<form.Form>`, `<form.TextField
+ * name="email" …/>`, `<form.Submit>`. Errors are i18n keys (`form.errors.tooShort`), never the engine's English.
+ */
+declare const createKrizakaForm: <S extends FormSchema>(definition: KrizakaFormDefinition<S>) => KrizakaFormFactory<S, {
+    TextField: typeof TextField;
+    TextArea: typeof TextArea;
+    Checkbox: typeof Checkbox;
+    Switch: typeof Switch;
+    RadioGroup: typeof RadioGroup;
+    Select: typeof Select;
+    Combobox: typeof Combobox;
+    DateField: typeof DateField;
+    TagInput: typeof TagInput;
+    FileUpload: typeof FileUpload;
+    Money: typeof Money;
+    Slider: typeof Slider;
+    Field: typeof FormField;
+    FieldArray: typeof FieldArray;
+    Watch: typeof Watch;
+    Submit: typeof Submit;
+    FormError: typeof FormError;
+}, Omit<React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "onSubmit" | "noValidate"> & {
+    /** The fields, the error and the button. */
+    children?: React.ReactNode;
+}>;
+/** The form sent by a Server Action: `useFormWithAction(signUp, createAccount)` — `signUp.useFormWithAction(createAccount)`. */
+declare function useFormWithAction<F extends {
+    useFormWithAction: (...args: never[]) => unknown;
+}>(form: F, ...args: Parameters<F["useFormWithAction"]>): ReturnType<F["useFormWithAction"]>;
+
+export { Checkbox, type CheckboxProps, Combobox, type ComboboxProps, DateField, type DateFieldProps, FieldArray, type FieldArrayProps, type FieldCheck, type FieldName, type FieldOptions, FileUpload, type FileUploadProps, type FormActionResult, type FormContextValue, FormError, type FormErrorProps, FormField, type FormFieldError, type FormFieldProps, type FormI18n, type FormMessageValue, type FormOption, type FormOutput, type FormProblem, type FormProps, type FormSchema, type FormValues, type KrizakaField, type KrizakaFieldArray, type KrizakaFormDefinition, type KrizakaFormFactory, type KrizakaFormInstance, Money, type MoneyProps, RadioGroup, type RadioGroupProps, Select, type SelectProps, Slider, type SliderProps, Submit, type SubmitProps, Switch, TagInput, type TagsProps, TextArea, type TextAreaProps, TextField, type TextFieldProps, type UseKrizakaFormOptions, Watch, type WatchProps, composeDate, createKrizakaForm, currencySymbol, datePartsOrder, formMessage, formMessages, isRealDate, issueError, issuesToFields, latestBirthDate, moneyInputText, parseMoney, problemToErrors, useFormContext, useFormStatus, useFormValue, useFormWithAction, useKrizakaField, useKrizakaFieldArray };