@k8ordo/form 0.1.1 → 1.1.0

package/dist/parse/parse-form.mjs

@@ -27,6 +27,19 @@ const rowCounts = (formData, arrays) => {
 	}
 	return counts;
 };
+/**
+* Whether the control submitted its own idea of "nothing". A number control
+* sends `''`, a select left on its placeholder sends `''`, and a file control
+* an unnamed empty File — none is a value anyone entered, and handing one to
+* the schema is how a blank field becomes 0 (`z.coerce.number()` reads `''` as
+* 0), an optional choice rejects the blank it allows, or an empty upload passes
+* for a real one. They arrive as `undefined` instead, which is the same thing
+* the derivation probed when it decided whether the field is required.
+*/
+const isUntouched = (kind, value) => {
+	if (kind === "number" || kind === "choice") return value === "";
+	return kind === "file" && value instanceof File && value.name === "" && value.size === 0;
+};
 const describeMissing = (missing) => {
 	const shown = missing.slice(0, 5).join(", ");
 	return missing.length > 5 ? `${shown} … ほか${String(missing.length - 5)}件` : shown;
@@ -46,6 +59,7 @@ const parseForm = (input, formData) => {
 	const raw = {};
 	const missing = [];
 	const secrets = /* @__PURE__ */ new Set();
+	const groups = /* @__PURE__ */ new Set();
 	const rows = rowCounts(formData, map.arrays);
 	for (const array of map.arrays) setPath(raw, array.path, Array.from({ length: rows[array.path] ?? 0 }));
 	const strings = (name) => formData.getAll(name).filter((value) => typeof value === "string");
@@ -54,32 +68,39 @@ const parseForm = (input, formData) => {
 		for (const name of names) {
 			if (leaf.json.input === "password") secrets.add(name);
 			if (leaf.group !== void 0) {
+				groups.add(name);
 				setPath(raw, name, strings(name));
 				continue;
 			}
-			if (leaf.json.type === "boolean") {
+			if (leaf.kind === "checkbox") {
 				setPath(raw, name, formData.has(name));
 				continue;
 			}
 			const entries = formData.getAll(name);
 			if (entries.length === 0) {
-				if (leaf.json.enum !== void 0) continue;
+				if (leaf.kind === "choice" || leaf.kind === "string-checkbox") {
+					setPath(raw, name, void 0);
+					continue;
+				}
 				missing.push(name);
 				continue;
 			}
-			setPath(raw, name, entries.length === 1 ? entries[0] : entries);
+			const value = entries.length === 1 ? entries[0] : entries;
+			setPath(raw, name, isUntouched(leaf.kind, value) ? void 0 : value);
 		}
 	}
 	if (missing.length > 0) throw new Error(`[@k8ordo/form] スキーマにあるフィールドが送信されていません: ${describeMissing(missing)}\ninput に name が付いていないか、その入力欄が描画されていない可能性があります。`);
 	const result = asProbe(schema).safeParse(raw);
 	const breaches = {};
 	for (const rule of rules) {
+		if (Object.hasOwn(breaches, rule.field)) continue;
 		const message = breachOf(rule, strings);
 		if (message !== void 0) breaches[rule.field] = message;
 	}
 	const values = {};
+	for (const name of groups) values[name] = strings(name);
 	for (const [name, value] of formData.entries()) {
-		if (typeof value !== "string" || secrets.has(name)) continue;
+		if (typeof value !== "string" || secrets.has(name) || groups.has(name)) continue;
 		const existing = values[name];
 		if (existing === void 0) values[name] = value;
 		else if (typeof existing === "string") values[name] = [existing, value];

package/dist/parse/paths.d.mts

@@ -6,15 +6,15 @@ type Step = {
   index: number;
 };
 /** Split `items[1].name` into its steps. */
-declare const stepsOf: (name: string) => Step[];
+export declare const stepsOf: (name: string) => Step[];
 /**
  * Write a value at a dotted/indexed path, creating the objects and arrays the
  * path implies. Gaps in an array stay holes rather than shifting later rows
  * onto earlier indexes, so a row removed on the client cannot silently
  * renumber the rows that follow.
  */
-declare const setPath: (root: Record<string, unknown>, name: string, value: unknown) => void;
+export declare const setPath: (root: Record<string, unknown>, name: string, value: unknown) => void;
 /** Turn a zod issue path into the `name` of the input that produced it. */
-declare const nameOf: (path: readonly PropertyKey[]) => string;
+export declare const nameOf: (path: readonly PropertyKey[]) => string;
 //#endregion
-export { nameOf, setPath, stepsOf };
+export {};

package/dist/paths.d.mts

@@ -7,7 +7,8 @@
  * is a field.
  *
  * Wrappers (`.optional()`, `.nullable()`, `.default()`, …) are peeled the same
- * way the runtime walk peels them, so the two advertise the same paths.
+ * way the runtime walk peels them, so the two advertise the same paths — except
+ * where the walk refuses the schema outright, as it does a nullable object.
  */
 type Join<Prefix extends string, Key extends string> = Prefix extends '' ? Key : `${Prefix}.${Key}`;
 /**
@@ -42,15 +43,44 @@ type IsEnum<Schema> = Unwrap<Schema> extends {
     };
   };
 } ? true : false;
-type FieldPathsOf<Schema, Prefix extends string = ''> = Unwrap<Schema> extends (infer Bare) ? IsArray<Bare> extends true ? IsEnum<ArrayElement<Bare>> extends true ? Prefix extends '' ? never : Prefix : never : Bare extends {
+export type FieldPathsOf<Schema, Prefix extends string = ''> = Unwrap<Schema> extends (infer Bare) ? IsArray<Bare> extends true ? IsEnum<ArrayElement<Bare>> extends true ? Prefix extends '' ? never : Prefix : never : Bare extends {
   shape: infer Shape;
 } ? { [Key in keyof Shape & string]: FieldPathsOf<Shape[Key], Join<Prefix, Key>>; }[keyof Shape & string] : Prefix extends '' ? never : Prefix : never;
 /**
  * No recursion into an array's element: a repeat inside a repeat has no
  * unambiguous name, and the runtime walk refuses it too.
  */
-type ArrayPathsOf<Schema, Prefix extends string = ''> = Unwrap<Schema> extends (infer Bare) ? IsArray<Bare> extends true ? IsEnum<ArrayElement<Bare>> extends true ? never : Prefix extends '' ? never : Prefix : Bare extends {
+export type ArrayPathsOf<Schema, Prefix extends string = ''> = Unwrap<Schema> extends (infer Bare) ? IsArray<Bare> extends true ? IsEnum<ArrayElement<Bare>> extends true ? never : Prefix extends '' ? never : Prefix : Bare extends {
   shape: infer Shape;
 } ? { [Key in keyof Shape & string]: ArrayPathsOf<Shape[Key], Join<Prefix, Key>>; }[keyof Shape & string] : never : never;
+/**
+ * The one control whose `input` carries a `value` is a checkbox whose schema
+ * reads the submitted string (`z.stringbool()`). The runtime walk finds it by
+ * encoding `true`, which takes a codec; the type sees the same codec as a
+ * string on its way in and a boolean on its way out. The string is read off
+ * the codec's inner schema because `zod/mini` leaves the codec's own input
+ * `unknown`.
+ */
+type EncodesTrueAsString<Schema> = Schema extends {
+  _zod: {
+    output: infer Output;
+    def: {
+      in: {
+        _zod: {
+          output: infer In;
+        };
+      };
+      reverseTransform: unknown;
+    };
+  };
+} ? [In] extends [string] ? [Output] extends [boolean] ? true : false : false : false;
+/**
+ * The field paths whose `input` carries the string a checked box submits.
+ * Arrays need no case of their own: neither a checkbox group nor repeated rows
+ * take a string in.
+ */
+export type StringCheckboxPathsOf<Schema, Prefix extends string = ''> = Unwrap<Schema> extends (infer Bare) ? Bare extends {
+  shape: infer Shape;
+} ? { [Key in keyof Shape & string]: StringCheckboxPathsOf<Shape[Key], Join<Prefix, Key>>; }[keyof Shape & string] : Prefix extends '' ? never : EncodesTrueAsString<Bare> extends true ? Prefix : never : never;
 //#endregion
-export { ArrayPathsOf, FieldPathsOf };
+export {};

package/dist/rules/define-form.d.mts

@@ -10,12 +10,11 @@ import { ObjectSchema } from "../schema/object-schema.mjs";
  * The rules are typed against the schema's own paths, so
  * `sameAs('confrim', …)` is a compile error, not a rule that never fires.
  */
-type FormDefinition<Schema extends ObjectSchema = ObjectSchema> = {
+export type FormDefinition<Schema extends ObjectSchema = ObjectSchema> = {
   schema: Schema;
   rules: Array<Rule<FieldPathsOf<Schema>>>;
 };
-declare const defineForm: <Schema extends ObjectSchema>(schema: Schema, rules?: Array<Rule<FieldPathsOf<Schema>>>) => FormDefinition<Schema>;
+export declare const defineForm: <Schema extends ObjectSchema>(schema: Schema, rules?: Array<Rule<FieldPathsOf<Schema>>>) => FormDefinition<Schema>;
 /** Accept either a bare schema or a definition, so rules stay optional. */
-declare const asDefinition: <Schema extends ObjectSchema>(input: FormDefinition<Schema> | Schema) => FormDefinition<Schema>;
-//#endregion
-export { FormDefinition, asDefinition, defineForm };
+export declare const asDefinition: <Schema extends ObjectSchema>(input: FormDefinition<Schema> | Schema) => FormDefinition<Schema>;
+//#endregion

package/dist/rules/rules.d.mts

@@ -10,32 +10,48 @@
  * it, so a typo in a field name fails to compile instead of producing a rule
  * that never fires.
  */
-type Rule<Field extends string = string> = {
+export type Rule<Field extends string = string> = RuleOf<Field, RuleMessage>;
+/**
+ * The text a broken rule reports, or a function returning it. Like zod's
+ * `{ error: () => … }`, the function is called when the rule is reported —
+ * `formFields` calls it as it derives the fields, `parseForm` when a rule
+ * breaks — so a message that follows the request (its locale, say) is
+ * declared once and read in whichever request reports it.
+ */
+export type RuleMessage = string | (() => string);
+/**
+ * A rule as it crosses to the client. A function cannot cross the RSC
+ * boundary, so `formFields` has already called it.
+ */
+export type DerivedRule = RuleOf<string, string>;
+type RuleOf<Field extends string, Message> = {
   kind: 'sameAs';
   field: Field;
   other: Field;
-  message: string;
+  message: Message;
 } | {
   kind: 'minChecked';
   field: Field;
   min: number;
-  message: string;
+  message: Message;
 } | {
   kind: 'requiredWhen';
   field: Field;
   when: Field;
   equals: string;
-  message: string;
+  message: Message;
 };
 /** Reads the current values of a name, however many controls carry it. */
-type Values = (name: string) => string[];
+export type Values = (name: string) => string[];
 /** The value must equal another field's. Password confirmation, and the like. */
-declare const sameAs: <Field extends string>(field: Field, other: Field, message: string) => Rule<Field>;
+export declare const sameAs: <Field extends string>(field: Field, other: Field, message: RuleMessage) => Rule<Field>;
 /** At least `min` boxes sharing this name must be checked. */
-declare const minChecked: <Field extends string>(field: Field, min: number, message: string) => Rule<Field>;
+export declare const minChecked: <Field extends string>(field: Field, min: number, message: RuleMessage) => Rule<Field>;
 /** Required only while another field holds a particular value. */
-declare const requiredWhen: <Field extends string>(field: Field, when: Field, equals: string, message: string) => Rule<Field>;
+export declare const requiredWhen: <Field extends string>(field: Field, when: Field, equals: string, message: RuleMessage) => Rule<Field>;
+/** The rule with its message called, ready to cross to the client. */
+export declare const deriveRule: (rule: Rule) => DerivedRule;
 /** The message when the rule is broken, or undefined when it holds. */
-declare const breachOf: (rule: Rule, values: Values) => string | undefined;
+export declare const breachOf: (rule: Rule, values: Values) => string | undefined;
 //#endregion
-export { Rule, Values, breachOf, minChecked, requiredWhen, sameAs };
+export {};

package/dist/rules/rules.mjs

@@ -22,14 +22,21 @@ const requiredWhen = (field, when, equals, message) => ({
 	message
 });
 const first = (values, name) => values(name)[0] ?? "";
-/** The message when the rule is broken, or undefined when it holds. */
-const breachOf = (rule, values) => {
+const holds = (rule, values) => {
 	switch (rule.kind) {
-		case "sameAs": return first(values, rule.field) === first(values, rule.other) ? void 0 : rule.message;
-		case "minChecked": return values(rule.field).length >= rule.min ? void 0 : rule.message;
-		case "requiredWhen": return first(values, rule.when) === rule.equals && first(values, rule.field) === "" ? rule.message : void 0;
-		default: return;
+		case "sameAs": return first(values, rule.field) === first(values, rule.other);
+		case "minChecked": return values(rule.field).length >= rule.min;
+		case "requiredWhen": return first(values, rule.when) !== rule.equals || first(values, rule.field) !== "";
+		default: return true;
 	}
 };
+const textOf = (message) => typeof message === "function" ? message() : message;
+/** The rule with its message called, ready to cross to the client. */
+const deriveRule = (rule) => ({
+	...rule,
+	message: textOf(rule.message)
+});
+/** The message when the rule is broken, or undefined when it holds. */
+const breachOf = (rule, values) => holds(rule, values) ? void 0 : textOf(rule.message);
 //#endregion
-export { breachOf, minChecked, requiredWhen, sameAs };
+export { breachOf, deriveRule, minChecked, requiredWhen, sameAs };

package/dist/schema/object-schema.d.mts

@@ -6,16 +6,18 @@ import { $ZodObject, $ZodShape, $ZodType } from "zod/v4/core";
  * `ZodObject` is what lets a caller pick the seven-times-smaller entry without
  * losing the types.
  */
-type ObjectSchema<Shape extends $ZodShape = $ZodShape> = $ZodObject<Shape> & {
+export type ObjectSchema<Shape extends $ZodShape = $ZodShape> = $ZodObject<Shape> & {
   shape: Shape;
 };
-type ProbeIssue = {
+export type ProbeIssue = {
   code: string;
+  /** Which string format rejected the value, on an `invalid_format` issue. */
+  format?: string;
   message: string;
   path: readonly PropertyKey[];
 };
 /** What probing needs, present on both entries but not on the core type. */
-type ProbeSchema = $ZodType & {
+export type ProbeSchema = $ZodType & {
   safeParse: (value: unknown) => {
     success: true;
     data: unknown;
@@ -28,6 +30,5 @@ type ProbeSchema = $ZodType & {
     };
   };
 };
-declare const asProbe: (schema: $ZodType) => ProbeSchema;
-//#endregion
-export { ObjectSchema, ProbeIssue, ProbeSchema, asProbe };
+export declare const asProbe: (schema: $ZodType) => ProbeSchema;
+//#endregion

package/dist/schema/walk.d.mts

@@ -1,10 +1,10 @@
-import { LeafSchema } from "../derive/attributes.mjs";
+import { ControlKind, LeafSchema } from "../derive/attributes.mjs";
 import { ObjectSchema } from "./object-schema.mjs";
 import { $ZodType } from "zod/v4/core";
 //#region src/schema/walk.d.ts
 /** Placeholder an array item's name carries until a row index is known. */
-declare const INDEX = "{index}";
-type LeafNode = {
+export declare const INDEX = "{index}";
+export type LeafNode = {
   /** Dotted path within the parsed object, e.g. `user.email`. */
   path: string;
   /** The `name` attribute, with {@link INDEX} still in it for array items. */
@@ -13,6 +13,9 @@ type LeafNode = {
     input?: string;
   };
   zod: $ZodType;
+  kind: ControlKind;
+  /** `string-checkbox` がチェック時に送る文字列（{@link checkedValueOf}）。 */
+  checkedValue?: string;
   required: boolean;
   /** The array this leaf repeats inside, or null. */
   arrayPath: string | null;
@@ -28,21 +31,26 @@ type LeafNode = {
     maxItems?: number;
   };
 };
-type ArrayNode = {
+export type ArrayNode = {
   path: string;
   name: string;
   minItems?: number;
   maxItems?: number;
 };
-type SchemaMap = {
+export type SchemaMap = {
   leaves: LeafNode[];
   arrays: ArrayNode[];
 };
+/**
+ * Peel wrapper schemas until the node that owns the structure is reached.
+ * `toJSONSchema` flattens `.optional()` / `.default()` into the plain node, so
+ * pairing the two trees requires flattening the zod side the same way.
+ */
+export declare const unwrap: ($schema: $ZodType) => $ZodType;
 /**
  * Describe a schema once: every leaf that becomes an input, and every array
  * that becomes a repeatable group. Both the derivation and the parse read this,
  * so the two can never disagree about what the form contains.
  */
-declare const schemaMap: (schema: ObjectSchema) => SchemaMap;
-//#endregion
-export { ArrayNode, INDEX, LeafNode, SchemaMap, schemaMap };
+export declare const schemaMap: (schema: ObjectSchema) => SchemaMap;
+//#endregion

package/dist/schema/walk.mjs

@@ -1,5 +1,6 @@
 import { asProbe } from "./object-schema.mjs";
-import { toJSONSchema } from "zod/v4/core";
+import { controlKindOf, emptySubmissionOf } from "../derive/attributes.mjs";
+import { safeEncode, toJSONSchema } from "zod/v4/core";
 //#region src/schema/walk.ts
 /** Placeholder an array item's name carries until a row index is known. */
 const INDEX = "{index}";
@@ -23,15 +24,74 @@ const elementOf = ($schema) => {
 	return candidate.element ?? candidate._zod?.def?.element;
 };
 /**
+* BigInt has no JSON Schema form, so its node arrives empty and reads as a
+* text control. It does render as one, but a blank one is no more a value than
+* a blank number is — `z.coerce.bigint()` reads `''` as 0n — so its submission
+* is judged the way a number's is.
+*/
+const kindOf = (json, $schema) => {
+	const kind = controlKindOf(json);
+	return kind === "text" && unwrap($schema)._zod?.def?.type === "bigint" ? "number" : kind;
+};
+/**
+* 文字列を読むスキーマのチェックボックスが、チェック時に送る文字列。スキーマ
+* 自身が `true` を encode した綴りを使う。ブラウザ既定の `on` を拒む
+* `z.stringbool({ truthy: ['yes'] })` にも読める値が届き、`@k8ordo/state` が
+* `true` として URL に書く文字列とも一致する。
+*/
+const checkedValueOf = ($schema) => {
+	try {
+		const encoded = safeEncode($schema, true);
+		return encoded.success && typeof encoded.data === "string" ? encoded.data : void 0;
+	} catch {
+		return;
+	}
+};
+/**
 * `required` in JSON Schema means "the key is present", but a form always
-* submits something for every control. What it submits depends on the control:
-* a text field sends `''`, an unchecked checkbox maps to `false` in the parse.
-* Asking the schema what it does with that empty submission is what makes the
-* attribute mean the same on both sides.
+* submits something for every control, and what that is depends on the control
+* — `emptySubmissionOf` is the one place that decides. Asking the schema what
+* it does with that exact value, which is also what the parse will hand it, is
+* what makes the attribute mean the same on both sides.
+*/
+const rejectsEmptySubmission = (kind, $schema) => !asProbe($schema).safeParse(emptySubmissionOf(kind)).success;
+/**
+* Strings a text control could plausibly submit. One is never enough: a schema
+* that coerces reads some strings and not others, and rejecting the one probe
+* that happens to be nonsense says nothing about the rest —
+* `z.coerce.date()` refuses a word and accepts a date.
 */
-const rejectsEmptySubmission = (json, $schema) => {
-	const empty = json.type === "boolean" ? false : "";
-	return !asProbe($schema).safeParse(empty).success;
+const TEXT_PROBES = [
+	"1",
+	"2000-01-01",
+	"k8ordo-probe"
+];
+const rejectsAsWrongType = ($schema, value) => {
+	const probed = asProbe($schema).safeParse(value);
+	return !probed.success && probed.error.issues.some((issue) => issue.code === "invalid_type");
+};
+/**
+* A text or number control can only submit strings, and the parse reads a
+* checkbox as a boolean unless its schema names a string to submit, so a leaf
+* that turns every such value away on type alone can never be satisfied by the
+* control it derives. That is not a check the client skips; it is a form that
+* always fails, so it is refused here rather than shipped, with the reason. (A
+* file is exempt: the parse hands the schema a File, which is what `z.file()`
+* reads.)
+*
+* A constraint is not a refusal: `z.coerce.number().min(100)` rejects the probe
+* with `too_small`, which is the schema doing its job.
+*/
+const refusalOf = (json, $schema, kind) => {
+	if (kind === "string-checkbox") return asProbe($schema).safeParse(void 0).data === true ? "チェックを外したボックスは何も送らないため、未送信を true と読むこのスキーマ（.default(true) など）では false を送れません。チェックすると true になる向きの項目にしてください" : void 0;
+	const control = controlKindOf(json);
+	if (control === "number") {
+		const asText = asProbe($schema).safeParse("1");
+		if (asText.success) return;
+		return asProbe($schema).safeParse(1).success || asText.error.issues.some((issue) => issue.code === "invalid_type") ? "フォームの値は文字列で届くため、このスキーマはどんな入力でも失敗します。z.coerce.number() を使ってください" : void 0;
+	}
+	if (kind === "checkbox") return [true, false].every((value) => rejectsAsWrongType($schema, value)) ? "チェックボックスは真偽値（z.boolean()）か、送信する文字列（z.stringbool()）として読むため、どちらでもないこのスキーマはどんな入力でも失敗します" : void 0;
+	if (control === "text" && json.type !== "string") return TEXT_PROBES.every((probe) => rejectsAsWrongType($schema, probe)) ? "このスキーマは文字列を受け付けないため、フォームが送信できる値がありません（z.date() や z.bigint() などは表現できません）" : void 0;
 };
 const fail = (path, reason) => {
 	throw new Error(`[@k8ordo/form] '${path === "" ? "(schema)" : path}': ${reason}`);
@@ -61,6 +121,7 @@ const walkNode = (json, zod, path, name, context, out) => {
 				name,
 				json: json.items,
 				zod: element,
+				kind: controlKindOf(json.items),
 				required: false,
 				arrayPath: context.arrayPath,
 				itemKey: context.itemKey,
@@ -89,12 +150,18 @@ const walkNode = (json, zod, path, name, context, out) => {
 	if (json.anyOf !== void 0) {
 		for (const branch of json.anyOf) if (branch.type === "object" || branch.type === "array") fail(path, "nullable / union のオブジェクトや配列は、どちらの枝を描画すべきか決まらないため表現できません");
 	}
+	const checkedValue = controlKindOf(json) === "checkbox" ? checkedValueOf(zod) : void 0;
+	const kind = checkedValue === void 0 ? kindOf(json, zod) : "string-checkbox";
+	const refusal = refusalOf(json, zod, kind);
+	if (refusal !== void 0) fail(path, refusal);
 	out.leaves.push({
 		path,
 		name,
 		json,
 		zod,
-		required: rejectsEmptySubmission(json, zod),
+		kind,
+		checkedValue,
+		required: rejectsEmptySubmission(kind, zod),
 		arrayPath: context.arrayPath,
 		itemKey: context.itemKey
 	});
@@ -125,4 +192,4 @@ const schemaMap = (schema) => {
 	return out;
 };
 //#endregion
-export { INDEX, schemaMap };
+export { INDEX, schemaMap, unwrap };

package/dist/server.d.mts

@@ -1,6 +1,6 @@
-import { Rule, minChecked, requiredWhen, sameAs } from "./rules/rules.mjs";
-import { DerivedArray, DerivedField, DroppedCheck, FieldInput, FormFields, FormState, ValidityFlag } from "./types.mjs";
+import { DerivedRule, Rule, RuleMessage, minChecked, requiredWhen, sameAs } from "./rules/rules.mjs";
+import { DerivedArray, DerivedField, DroppedCheck, FieldInput, FormFields, FormState, StringCheckboxInput, ValidityFlag } from "./types.mjs";
 import { FormDefinition, defineForm } from "./rules/define-form.mjs";
 import { formFields } from "./derive/form-fields.mjs";
 import { ParseResult, parseForm } from "./parse/parse-form.mjs";
-export { type DerivedArray, type DerivedField, type DroppedCheck, type FieldInput, type FormDefinition, type FormFields, type FormState, type ParseResult, type Rule, type ValidityFlag, defineForm, formFields, minChecked, parseForm, requiredWhen, sameAs };
+export { type DerivedArray, type DerivedField, type DerivedRule, type DroppedCheck, type FieldInput, type FormDefinition, type FormFields, type FormState, type ParseResult, type Rule, type RuleMessage, type StringCheckboxInput, type ValidityFlag, defineForm, formFields, minChecked, parseForm, requiredWhen, sameAs };

package/dist/types.d.mts

@@ -1,27 +1,37 @@
-import { Rule } from "./rules/rules.mjs";
+import { DerivedRule } from "./rules/rules.mjs";
 //#region src/types.d.ts
 /** ValidityState flags a derived field can report a message for. */
-type ValidityFlag = 'badInput' | 'patternMismatch' | 'rangeOverflow' | 'rangeUnderflow' | 'stepMismatch' | 'tooLong' | 'tooShort' | 'typeMismatch' | 'valueMissing';
+export type ValidityFlag = 'badInput' | 'patternMismatch' | 'rangeOverflow' | 'rangeUnderflow' | 'stepMismatch' | 'tooLong' | 'tooShort' | 'typeMismatch' | 'valueMissing';
 /** Attributes spread onto the input element itself. */
-type FieldInput = {
+export type FieldInput = {
   name: string;
   type?: string;
   required?: boolean;
   minLength?: number;
   maxLength?: number;
   pattern?: string;
+  /** Comma-separated mime types for a file control, from `.mime()`. */
+  accept?: string;
   min?: number | string;
   max?: number | string;
   step?: number | 'any';
   defaultValue?: string;
   defaultChecked?: boolean;
 };
+/**
+ * The input of a checkbox whose schema reads the submitted string
+ * (`z.stringbool()`): it also carries what a checked box submits.
+ */
+export type StringCheckboxInput = FieldInput & {
+  /** The schema's own spelling of `true`. */
+  value?: string;
+};
 /**
  * One field as derived from the schema. Serializable on purpose: it crosses the
  * RSC boundary as props, which is what keeps zod out of the client bundle.
  */
-type DerivedField = {
-  input: FieldInput;
+export type DerivedField<Input extends FieldInput = FieldInput> = {
+  input: Input;
   /** Message per ValidityState flag, taken from zod itself. */
   messages: Partial<Record<ValidityFlag, string>>;
   /** True when the input must not be echoed back after a failed submit. */
@@ -31,7 +41,7 @@ type DerivedField = {
  * A repeatable group. The item is described once; the row index is filled into
  * the name when a row renders, because rows do not exist until then.
  */
-type DerivedArray = {
+export type DerivedArray = {
   path: string;
   minItems?: number;
   maxItems?: number;
@@ -39,27 +49,39 @@ type DerivedArray = {
   item: Record<string, DerivedField>;
 };
 /** What a constraint-carrying check lost on its way to HTML. */
-type DroppedCheck = {
+export type DroppedCheck = {
   field: string;
   reason: string;
 };
-type FormFields<FieldPath extends string = string, ArrayPath extends string = string> = {
-  fields: Record<FieldPath, DerivedField>;
+/**
+ * `StringCheckboxPath` names the fields whose `input` carries `value`.
+ * `formFields` fills it in from the schema; a type written by hand that leaves
+ * it out still takes the derived fields, and only hides `value` from `field()`.
+ */
+export type FormFields<FieldPath extends string = string, ArrayPath extends string = string, StringCheckboxPath extends string = never> = {
+  fields: Record<FieldPath, DerivedField> & Record<StringCheckboxPath, DerivedField<StringCheckboxInput>>;
   arrays: Record<ArrayPath, DerivedArray>;
-  /** Checks HTML has no attribute for, evaluated identically on both sides. */
-  rules: Rule[];
-  /** Checks that HTML cannot express. Reported once, never silently discarded. */
+  /**
+   * Checks HTML has no attribute for, each run by the same evaluator on both
+   * sides. A function message has already been called.
+   */
+  rules: DerivedRule[];
+  /**
+   * Checks that HTML cannot express, returned instead of silently discarded.
+   * Not every such check is listed yet; the guide names the gaps.
+   */
   dropped: DroppedCheck[];
 };
 /**
  * What a Server Action hands back to the form. Keys are dotted paths, so an
  * error on a row reads as `items[1].name`.
  */
-type FormState = {
+export type FormState = {
   errors?: Record<string, string>;
   /**
-   * Submitted values for re-render. Secret fields are never included; a name
-   * several controls share — a checkbox group — echoes as an array.
+   * Submitted values for re-render. Secret fields and files are never
+   * included; a checkbox group echoes as an array however many boxes were
+   * checked, and any other name submitted more than once as an array too.
    */
   values?: Record<string, string | string[]>;
   /** How many rows each array had, so a no-JS retry rebuilds them. */
@@ -72,5 +94,4 @@ type FormState = {
    */
   token?: string;
 };
-//#endregion
-export { DerivedArray, DerivedField, DroppedCheck, FieldInput, FormFields, FormState, ValidityFlag };
+//#endregion