@whatsaaaa/form-builder-schema 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,4 +1,21 @@
 import * as v from "valibot";
+// src/errors/definition-error.ts
+function formatPath(path) {
+	return path.reduce((out, key) => {
+		if (typeof key === "number") return `${out}[${key}]`;
+		return out ? `${out}.${key}` : key;
+	}, "");
+}
+/** Thrown by `build()` when the definition has issues. Lists all of them. */
+var DefinitionError = class extends Error {
+	issues;
+	constructor(issues) {
+		const lines = issues.map((issue) => `   ${formatPath(issue.path) || "(root)"}: ${issue.message}`);
+		super(`Invalid form definition:\n${lines.join("\n")}`);
+		this.name = "DefinitionError";
+		this.issues = issues;
+	}
+};
 // src/shared/each-item.ts
 /**
 * Checks every item of an array with `schema` and reports the issues on the array itself.
@@ -23,9 +40,10 @@ function eachItem(schema) {
 /**
 * The schema runs in this order: empty check, base schema, normalize rules, required check,
 * then the type's default rules and the field's rules, and last the type's `finalize()`.
+* A container has no empty check: its value is never empty.
 */
-function buildFieldSchema(checked, messages) {
-	const { field, path, type, kind } = checked;
+function buildFieldSchema(checked, messages, ctx) {
+	const { field, path, type, kind, valueKind } = checked;
 	const required = !!field.required;
 	const requiredMessage = messages.resolve(typeof field.required === "object" && field.required.message || messages.required, {
 		field,
@@ -54,15 +72,52 @@ function buildFieldSchema(checked, messages) {
 	if (each.validate.length) whole.validate.unshift(eachItem(pipe(v.unknown(), each.validate)));
 	const finalize = type.finalize?.(field);
 	if (finalize) whole.validate.push(finalize);
-	const base = type.schema(field, { path });
+	const base = type.schema(field, ctx);
 	const requiredCheck = !required ? void 0 : type.required ? type.required(requiredMessage) : kind.required?.(requiredMessage);
 	const head = pipe(base, requiredCheck ? [...whole.normalize, requiredCheck] : whole.normalize);
+	if (type.container) {
+		const rules = whole.validate.length ? [pipe(v.unknown(), whole.validate)] : [];
+		return v.optional(pipe(head, rules), valueKind === "object" ? () => ({}) : () => []);
+	}
 	const empty = required ? v.never(requiredMessage) : v.pipe(v.unknown(), v.transform(() => void 0));
 	const whenFilled = (schema) => v.lazy((input) => kind.isEmpty(input) ? empty : schema);
 	const schema = whenFilled(v.pipe(head, whenFilled(pipe(v.unknown(), whole.validate))));
 	return required ? schema : v.optional(schema);
 }
 const pipe = (schema, items) => items.reduce((acc, item) => v.pipe(acc, item), schema);
+// src/shared/reserved-keys.ts
+/**
+* Field keys this package owns. A field type's props can't use them.
+*/
+const RESERVED_FIELD_KEYS = [
+	"name",
+	"type",
+	"label",
+	"description",
+	"placeholder",
+	"default",
+	"required",
+	"rules",
+	"ui"
+];
+/**
+* Rule keys this package owns. A rule's params can't use them.
+*/
+const RESERVED_RULE_KEYS = ["rule", "message"];
+/**
+* Form rule keys this package owns. A form rule's params can't use them.
+*/
+const RESERVED_FORM_RULE_KEYS = [
+	"rule",
+	"field",
+	"message"
+];
+const fieldKeys = new Set(RESERVED_FIELD_KEYS);
+const ruleKeys = new Set(RESERVED_RULE_KEYS);
+const formRuleKeys = new Set(RESERVED_FORM_RULE_KEYS);
+const isReservedFieldKey = (key) => fieldKeys.has(key);
+const isReservedRuleKey = (key) => ruleKeys.has(key);
+const isReservedFormRuleKey = (key) => formRuleKeys.has(key);
 // src/field-types/basic-types.ts
 /** Types with one plain value and no props. Each maps to a native input. */
 const basicTypes = {
@@ -147,6 +202,26 @@ const choiceTypes = {
 		schema: (field) => v.array(oneOf(field.options))
 	})
 };
+// src/field-types/container-types.ts
+const childField = v.custom(() => true);
+/** Types whose value holds other fields. Display elements can go inside them too. */
+const containerTypes = {
+	group: defineFieldType({
+		kind: "object",
+		container: true,
+		props: v.object({ fields: v.array(childField) }),
+		schema: (field, ctx) => ctx.buildFields(field.fields, [...ctx.path, "fields"])
+	}),
+	array: defineFieldType({
+		kind: "array",
+		container: true,
+		props: v.pipe(v.object({
+			of: v.optional(childField),
+			fields: v.optional(v.array(childField))
+		}), v.check((props) => props.of === void 0 !== (props.fields === void 0), "Give exactly one of \"of\" and \"fields\"")),
+		schema: (field, ctx) => v.array(field.of ? ctx.buildField(field.of, [...ctx.path, "of"]) : ctx.buildFields(field.fields ?? [], [...ctx.path, "fields"]))
+	})
+};
 // src/field-types/date-types.ts
 const outputProps = v.object({ 
 /** `'date'` turns the ISO string into a `Date`. Defaults to `'string'`. */
@@ -221,7 +296,8 @@ const defaultFieldTypes = {
 	...dateTypes,
 	...choiceTypes,
 	file: fileType,
-	...displayTypes
+	...displayTypes,
+	...containerTypes
 };
 // src/kinds/default-kinds.ts
 const isNil = (input) => input === void 0 || input === null;
@@ -272,7 +348,7 @@ const any = [
 	"string",
 	"boolean"
 ];
-const meta$6 = (label) => ({
+const meta$7 = (label) => ({
 	label,
 	category: "comparison"
 });
@@ -283,54 +359,54 @@ const comparisonRules = {
 	minValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Minimum"),
+		meta: meta$7("Minimum"),
 		create: (p, m) => v.minValue(p.value, m)
 	}),
 	maxValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Maximum"),
+		meta: meta$7("Maximum"),
 		create: (p, m) => v.maxValue(p.value, m)
 	}),
 	gtValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Greater than"),
+		meta: meta$7("Greater than"),
 		create: (p, m) => v.gtValue(p.value, m)
 	}),
 	ltValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Less than"),
+		meta: meta$7("Less than"),
 		create: (p, m) => v.ltValue(p.value, m)
 	}),
 	value: defineRule({
 		kinds: any,
 		params: valueParams,
-		meta: meta$6("Equals"),
+		meta: meta$7("Equals"),
 		create: (p, m) => v.value(p.value, m)
 	}),
 	notValue: defineRule({
 		kinds: any,
 		params: valueParams,
-		meta: meta$6("Does not equal"),
+		meta: meta$7("Does not equal"),
 		create: (p, m) => v.notValue(p.value, m)
 	}),
 	values: defineRule({
 		kinds: ordered,
 		params: valuesParams,
-		meta: meta$6("One of"),
+		meta: meta$7("One of"),
 		create: (p, m) => v.values(p.values, m)
 	}),
 	notValues: defineRule({
 		kinds: ordered,
 		params: valuesParams,
-		meta: meta$6("None of"),
+		meta: meta$7("None of"),
 		create: (p, m) => v.notValues(p.values, m)
 	})
 };
 // src/rules/content-rules.ts
-const meta$5 = (label, description) => ({
+const meta$6 = (label, description) => ({
 	label,
 	description,
 	category: "content"
@@ -359,31 +435,31 @@ const contentRules = {
 	regex: defineRule({
 		kinds: ["string"],
 		params: regexParams,
-		meta: meta$5("Matches pattern", "A JavaScript regular expression, without the slashes."),
+		meta: meta$6("Matches pattern", "A JavaScript regular expression, without the slashes."),
 		create: (p, m) => v.regex(new RegExp(p.pattern, p.flags?.replace(/[gy]/g, "")), m)
 	}),
 	startsWith: defineRule({
 		kinds: ["string"],
 		params: stringParams,
-		meta: meta$5("Starts with"),
+		meta: meta$6("Starts with"),
 		create: (p, m) => v.startsWith(p.value, m)
 	}),
 	endsWith: defineRule({
 		kinds: ["string"],
 		params: stringParams,
-		meta: meta$5("Ends with"),
+		meta: meta$6("Ends with"),
 		create: (p, m) => v.endsWith(p.value, m)
 	}),
 	includes: defineRule({
 		kinds: ["string", "array"],
 		params: contentParams,
-		meta: meta$5("Contains"),
+		meta: meta$6("Contains"),
 		create: (p, m) => v.includes(p.value, m)
 	}),
 	excludes: defineRule({
 		kinds: ["string", "array"],
 		params: contentParams,
-		meta: meta$5("Does not contain"),
+		meta: meta$6("Does not contain"),
 		create: (p, m) => v.excludes(p.value, m)
 	})
 };
@@ -407,7 +483,7 @@ const dateRules = {
 };
 // src/rules/file-rules.ts
 const kinds$3 = ["file"];
-const meta$4 = (label, description) => ({
+const meta$5 = (label, description) => ({
 	label,
 	description,
 	category: "file"
@@ -419,31 +495,31 @@ const fileRules = {
 	minSize: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Minimum size", bytes),
+		meta: meta$5("Minimum size", bytes),
 		create: (p, m) => v.minSize(p.value, m)
 	}),
 	maxSize: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Maximum size", bytes),
+		meta: meta$5("Maximum size", bytes),
 		create: (p, m) => v.maxSize(p.value, m)
 	}),
 	size: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Exact size", bytes),
+		meta: meta$5("Exact size", bytes),
 		create: (p, m) => v.size(p.value, m)
 	}),
 	notSize: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Not this size", bytes),
+		meta: meta$5("Not this size", bytes),
 		create: (p, m) => v.notSize(p.value, m)
 	}),
 	mimeType: defineRule({
 		kinds: kinds$3,
 		params: mimeTypeParams,
-		meta: meta$4("File type"),
+		meta: meta$5("File type"),
 		create: (p, m) => v.mimeType(p.types, m)
 	})
 };
@@ -514,7 +590,7 @@ const formatRules = {
 };
 // src/rules/length-rules.ts
 const kinds$2 = ["string", "array"];
-const meta$3 = (label) => ({
+const meta$4 = (label) => ({
 	label,
 	category: "length"
 });
@@ -523,31 +599,31 @@ const lengthRules = {
 	length: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Exact length"),
+		meta: meta$4("Exact length"),
 		create: (p, m) => v.length(p.value, m)
 	}),
 	minLength: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Minimum length"),
+		meta: meta$4("Minimum length"),
 		create: (p, m) => v.minLength(p.value, m)
 	}),
 	maxLength: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Maximum length"),
+		meta: meta$4("Maximum length"),
 		create: (p, m) => v.maxLength(p.value, m)
 	}),
 	notLength: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Not this length"),
+		meta: meta$4("Not this length"),
 		create: (p, m) => v.notLength(p.value, m)
 	})
 };
 // src/rules/normalize-rules.ts
 const stage = "normalize";
-const meta$2 = (label, description) => ({
+const meta$3 = (label, description) => ({
 	label,
 	description,
 	category: "normalize"
@@ -561,31 +637,31 @@ const normalizeRules = {
 	trim: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Trim"),
+		meta: meta$3("Trim"),
 		create: () => v.trim()
 	}),
 	trimStart: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Trim start"),
+		meta: meta$3("Trim start"),
 		create: () => v.trimStart()
 	}),
 	trimEnd: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Trim end"),
+		meta: meta$3("Trim end"),
 		create: () => v.trimEnd()
 	}),
 	toLowerCase: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Lowercase"),
+		meta: meta$3("Lowercase"),
 		create: () => v.toLowerCase()
 	}),
 	toUpperCase: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Uppercase"),
+		meta: meta$3("Uppercase"),
 		create: () => v.toUpperCase()
 	}),
 	normalize: defineRule({
@@ -597,27 +673,27 @@ const normalizeRules = {
 			"NFKC",
 			"NFKD"
 		])) }),
-		meta: meta$2("Unicode normalize", "Defaults to NFC."),
+		meta: meta$3("Unicode normalize", "Defaults to NFC."),
 		create: (p) => v.normalize(p.form)
 	}),
 	toMinValue: defineRule({
 		kinds: ["number"],
 		stage,
 		params: limit,
-		meta: meta$2("Raise to minimum", "Replaces a smaller number with the minimum."),
+		meta: meta$3("Raise to minimum", "Replaces a smaller number with the minimum."),
 		create: (p) => v.toMinValue(p.value)
 	}),
 	toMaxValue: defineRule({
 		kinds: ["number"],
 		stage,
 		params: limit,
-		meta: meta$2("Lower to maximum", "Replaces a larger number with the maximum."),
+		meta: meta$3("Lower to maximum", "Replaces a larger number with the maximum."),
 		create: (p) => v.toMaxValue(p.value)
 	})
 };
 // src/rules/number-rules.ts
 const kinds$1 = ["number"];
-const meta$1 = (label) => ({
+const meta$2 = (label) => ({
 	label,
 	category: "number"
 });
@@ -626,29 +702,29 @@ const divisor = v.pipe(v.number(), v.finite(), v.notValue(0, "Can't be 0"));
 const numberRules = {
 	integer: defineRule({
 		kinds: kinds$1,
-		meta: meta$1("Whole number"),
+		meta: meta$2("Whole number"),
 		create: (_, m) => v.integer(m)
 	}),
 	safeInteger: defineRule({
 		kinds: kinds$1,
-		meta: meta$1("Safe whole number"),
+		meta: meta$2("Safe whole number"),
 		create: (_, m) => v.safeInteger(m)
 	}),
 	finite: defineRule({
 		kinds: kinds$1,
-		meta: meta$1("Finite number"),
+		meta: meta$2("Finite number"),
 		create: (_, m) => v.finite(m)
 	}),
 	multipleOf: defineRule({
 		kinds: kinds$1,
 		params: v.object({ value: divisor }),
-		meta: meta$1("Multiple of"),
+		meta: meta$2("Multiple of"),
 		create: (p, m) => v.multipleOf(p.value, m)
 	})
 };
 // src/rules/text-unit-rules.ts
 const kinds = ["string"];
-const meta = (label, description) => ({
+const meta$1 = (label, description) => ({
 	label,
 	description,
 	category: "text"
@@ -670,73 +746,73 @@ const textUnitRules = {
 	graphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Exact characters", graphemesInfo),
+		meta: meta$1("Exact characters", graphemesInfo),
 		create: (p, m) => v.graphemes(p.value, m)
 	}),
 	minGraphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Minimum characters", graphemesInfo),
+		meta: meta$1("Minimum characters", graphemesInfo),
 		create: (p, m) => v.minGraphemes(p.value, m)
 	}),
 	maxGraphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Maximum characters", graphemesInfo),
+		meta: meta$1("Maximum characters", graphemesInfo),
 		create: (p, m) => v.maxGraphemes(p.value, m)
 	}),
 	notGraphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Not this many characters", graphemesInfo),
+		meta: meta$1("Not this many characters", graphemesInfo),
 		create: (p, m) => v.notGraphemes(p.value, m)
 	}),
 	words: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Exact words"),
+		meta: meta$1("Exact words"),
 		create: (p, m) => v.words(p.locale, p.value, m)
 	}),
 	minWords: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Minimum words"),
+		meta: meta$1("Minimum words"),
 		create: (p, m) => v.minWords(p.locale, p.value, m)
 	}),
 	maxWords: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Maximum words"),
+		meta: meta$1("Maximum words"),
 		create: (p, m) => v.maxWords(p.locale, p.value, m)
 	}),
 	notWords: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Not this many words"),
+		meta: meta$1("Not this many words"),
 		create: (p, m) => v.notWords(p.locale, p.value, m)
 	}),
 	bytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Exact bytes", bytesInfo),
+		meta: meta$1("Exact bytes", bytesInfo),
 		create: (p, m) => v.bytes(p.value, m)
 	}),
 	minBytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Minimum bytes", bytesInfo),
+		meta: meta$1("Minimum bytes", bytesInfo),
 		create: (p, m) => v.minBytes(p.value, m)
 	}),
 	maxBytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Maximum bytes", bytesInfo),
+		meta: meta$1("Maximum bytes", bytesInfo),
 		create: (p, m) => v.maxBytes(p.value, m)
 	}),
 	notBytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Not this many bytes", bytesInfo),
+		meta: meta$1("Not this many bytes", bytesInfo),
 		create: (p, m) => v.notBytes(p.value, m)
 	})
 };
@@ -753,10 +829,71 @@ const defaultRules = {
 	...fileRules,
 	...normalizeRules
 };
+// src/rules/define-form-rule.ts
+const defineFormRule = (def) => def;
+// src/rules/form-rules.ts
+const meta = (label, description) => ({
+	label,
+	description,
+	category: "comparison"
+});
+const comparable = (value) => value instanceof Date ? value.getTime() : value;
+const otherParams = v.object({ other: v.string() });
+const operators = {
+	lt: (a, b) => a < b,
+	lte: (a, b) => a <= b,
+	gt: (a, b) => a > b,
+	gte: (a, b) => a >= b
+};
+/** Every built-in form rule. */
+const defaultFormRules = {
+	sameAs: defineFormRule({
+		params: otherParams,
+		reads: (params) => [params.other],
+		kinds: [
+			"string",
+			"number",
+			"boolean",
+			"date"
+		],
+		sameKind: true,
+		meta: meta("Same as", "Equals another field, e.g. to confirm a password"),
+		check: ([value, other]) => comparable(value) === comparable(other)
+	}),
+	differentFrom: defineFormRule({
+		params: otherParams,
+		reads: (params) => [params.other],
+		kinds: [
+			"string",
+			"number",
+			"boolean",
+			"date"
+		],
+		sameKind: true,
+		meta: meta("Different from", "Differs from another field, e.g. a new password"),
+		check: ([value, other]) => comparable(value) !== comparable(other)
+	}),
+	compare: defineFormRule({
+		params: v.object({
+			op: v.picklist([
+				"lt",
+				"lte",
+				"gt",
+				"gte"
+			]),
+			other: v.string()
+		}),
+		reads: (params) => [params.other],
+		kinds: ["number", "date"],
+		sameKind: true,
+		meta: meta("Compare", "Less or greater than another field, e.g. an end date after the start"),
+		check: ([value, other], { op }) => operators[op](comparable(value), comparable(other))
+	})
+};
 // src/builder/registry.ts
 /** Consumer entries replace defaults with the same key. */
 function mergeRegistry(custom) {
-	const rules = custom.includeDefaultRules === false ? {} : defaultRules;
+	const defaults = custom.includeDefaultRules !== false;
 	return {
 		kinds: Object.freeze({
 			...defaultKinds,
@@ -767,31 +904,18 @@ function mergeRegistry(custom) {
 			...custom.fieldTypes
 		}),
 		rules: Object.freeze({
-			...rules,
+			...defaults ? defaultRules : {},
 			...custom.rules
+		}),
+		formRules: Object.freeze({
+			...defaults ? defaultFormRules : {},
+			...custom.formRules
 		})
 	};
 }
 function lookup(record, key) {
 	return Object.hasOwn(record, key) ? record[key] : void 0;
 }
-// src/errors/definition-error.ts
-function formatPath(path) {
-	return path.reduce((out, key) => {
-		if (typeof key === "number") return `${out}[${key}]`;
-		return out ? `${out}.${key}` : key;
-	}, "");
-}
-/** Thrown by `build()` when the definition has issues. Lists all of them. */
-var DefinitionError = class extends Error {
-	issues;
-	constructor(issues) {
-		const lines = issues.map((issue) => `   ${formatPath(issue.path) || "(root)"}: ${issue.message}`);
-		super(`Invalid form definition:\n${lines.join("\n")}`);
-		this.name = "DefinitionError";
-		this.issues = issues;
-	}
-};
 // src/rules/rule-params.ts
 const cache = /* @__PURE__ */ new WeakMap();
 function paramsFor(def, kind) {
@@ -808,34 +932,7 @@ function paramsFor(def, kind) {
 	}
 	return params;
 }
-// src/shared/reserved-keys.ts
-/**
-* Field keys this package owns. A field type's props can't use them.
-*/
-const RESERVED_FIELD_KEYS = [
-	"name",
-	"type",
-	"label",
-	"description",
-	"placeholder",
-	"default",
-	"required",
-	"rules",
-	"ui"
-];
-/**
-* Rule keys this package owns. A rule's params can't use them.
-*/
-const RESERVED_RULE_KEYS = ["rule", "message"];
-const fieldKeys = new Set(RESERVED_FIELD_KEYS);
-const ruleKeys = new Set(RESERVED_RULE_KEYS);
-const isReservedFieldKey = (key) => fieldKeys.has(key);
-const isReservedRuleKey = (key) => ruleKeys.has(key);
 // src/builder/validate-definition.ts
-const formShape = v.object({
-	version: v.string(),
-	fields: v.array(v.unknown())
-});
 const fieldShape = v.looseObject({
 	name: v.optional(v.string()),
 	type: v.string(),
@@ -847,40 +944,18 @@ const fieldShape = v.looseObject({
 	rules: v.optional(v.array(v.unknown())),
 	ui: v.optional(v.record(v.string(), v.unknown()))
 });
-const ruleShape = v.looseObject({
+const ruleShape$1 = v.looseObject({
 	rule: v.string(),
 	message: v.optional(v.string())
 });
 const noParams = v.object({});
 /**
-* Checks a whole definition and collects every issue, in document order. Never throws.
+* Checks one field's shape, name, type, props and rules, and adds its issues to `issues`.
+* Returns the field ready to build, or undefined when it has issues or no value.
+*
+* `names` holds the names used so far at this level. It is undefined for the field of a list's
+* items, which needs no name.
 */
-function checkDefinition(json, registry) {
-	const issues = [];
-	const fields = [];
-	const form = v.safeParse(formShape, json);
-	if (!form.success) return {
-		issues: toIssues("invalid_shape", [], form.issues),
-		fields
-	};
-	if (form.output.version !== "1") return {
-		issues: [{
-			code: "unsupported_version",
-			path: ["version"],
-			message: `Unsupported version "${form.output.version}". This package reads version '1'.`
-		}],
-		fields
-	};
-	const names = /* @__PURE__ */ new Set();
-	form.output.fields.forEach((raw, i) => {
-		const field = checkField(raw, ["fields", i], registry, names, issues);
-		if (field) fields.push(field);
-	});
-	return {
-		issues,
-		fields
-	};
-}
 function checkField(raw, path, registry, names, issues) {
 	const shape = v.safeParse(fieldShape, raw);
 	if (!shape.success) {
@@ -891,9 +966,13 @@ function checkField(raw, path, registry, names, issues) {
 	const issueCount = issues.length;
 	const type = lookup(registry.fieldTypes, field.type);
 	const hasValue = type?.kind !== "none";
-	if (!field.name) {
+	if (!names) {} else if (!field.name) {
 		if (type && hasValue) issues.push(issue("missing_name", [...path, "name"], "A field needs a name"));
 	} else if (hasValue) {
+		if (/[.[\]]/.test(field.name)) {
+			const message = `Name "${field.name}" can't contain ".", "[" or "]"`;
+			issues.push(issue("invalid_name", [...path, "name"], message));
+		}
 		if (names.has(field.name)) issues.push(issue("duplicate_name", [...path, "name"], `Duplicate name "${field.name}"`));
 		names.add(field.name);
 	}
@@ -907,6 +986,10 @@ function checkField(raw, path, registry, names, issues) {
 			const message = `A "${field.type}" field has no value, so it can't have "${key}"`;
 			issues.push(issue("invalid_shape", [...path, key], message));
 		}
+		if (!names) {
+			const message = `A list's items need a value, and a "${field.type}" field has none`;
+			issues.push(issue("invalid_shape", [...path, "type"], message));
+		}
 		return;
 	}
 	const withProps = props && {
@@ -919,12 +1002,18 @@ function checkField(raw, path, registry, names, issues) {
 		kind,
 		itemKind: kind === "array" ? resolveKind(type.itemKind, withProps) : void 0
 	};
+	if (type.container && kind === "object") {
+		for (const key of ["required", "default"]) if (field[key] !== void 0) {
+			const message = `A "${field.type}" field is always there, so it can't have "${key}"`;
+			issues.push(issue("invalid_shape", [...path, key], message));
+		}
+	}
 	const fieldRules = (shape.output.rules ?? []).flatMap((rule, j) => checkRule(rule, kinds, [
 		...path,
 		"rules",
 		j
 	], registry, issues) ?? []);
-	if (issues.length > issueCount || !field.name || !withProps) return void 0;
+	if (issues.length > issueCount || names && !field.name || !withProps) return void 0;
 	const overridden = new Set(fieldRules.map((rule) => rule.name));
 	const defaultRules = checkDefaultRules(field.type, type, kinds, registry).filter((rule) => !overridden.has(rule.name));
 	return {
@@ -933,6 +1022,7 @@ function checkField(raw, path, registry, names, issues) {
 		path,
 		type,
 		kind: kindDef(field.type, kind, registry),
+		valueKind: kind,
 		rules: [...defaultRules, ...fieldRules]
 	};
 }
@@ -970,7 +1060,7 @@ function checkProps(field, type, path, issues) {
 	issues.push(...toIssues("invalid_props", path, parsed.issues));
 }
 function checkRule(raw, { kind, itemKind }, path, registry, issues) {
-	const shape = v.safeParse(ruleShape, raw);
+	const shape = v.safeParse(ruleShape$1, raw);
 	if (!shape.success) {
 		issues.push(...toIssues("invalid_shape", path, shape.issues));
 		return;
@@ -988,31 +1078,42 @@ function checkRule(raw, { kind, itemKind }, path, registry, issues) {
 		issues.push(issue("kind_mismatch", [...path, "rule"], message));
 		return;
 	}
+	const params = checkParams(rule, paramsFor(def, each ? itemKind : kind), isReservedRuleKey, `Rule "${rule.rule}"`, path, issues);
+	if (!params) return void 0;
+	return {
+		name: rule.rule,
+		def,
+		params,
+		message: rule.message,
+		each
+	};
+}
+/**
+* Checks the params of a rule or a form rule. Every key that isn't reserved must be one of
+* `params`, and together they must pass it. Returns the parsed params, or undefined when they
+* have issues. `at` names the rule in messages, e.g. `Rule "minLength"`.
+*/
+function checkParams(raw, params, isReserved, at, path, issues) {
 	const issueCount = issues.length;
-	const params = paramsFor(def, each ? itemKind : kind);
 	const paramKeys = Object.keys(params?.entries ?? {});
 	const input = {};
-	for (const key of Object.keys(rule)) {
-		if (isReservedRuleKey(key)) continue;
-		if (paramKeys.includes(key)) input[key] = rule[key];
-		else issues.push(issue("unknown_param", [...path, key], `Rule "${rule.rule}" has no param "${key}"`));
+	for (const key of Object.keys(raw)) {
+		if (isReserved(key)) continue;
+		if (paramKeys.includes(key)) input[key] = raw[key];
+		else issues.push(issue("unknown_param", [...path, key], `${at} has no param "${key}"`));
 	}
 	const parsed = v.safeParse(params ?? noParams, input);
 	if (!parsed.success) issues.push(...toIssues("invalid_params", path, parsed.issues));
 	if (!parsed.success || issues.length > issueCount) return void 0;
-	return {
-		name: rule.rule,
-		def,
-		params: parsed.output,
-		message: rule.message,
-		each
-	};
+	return parsed.output;
 }
 function checkRegistry(registry) {
 	for (const [name, rule] of Object.entries(registry.rules)) for (const kind of rule.kinds) for (const key of Object.keys(paramsFor(rule, kind)?.entries ?? {})) if (isReservedRuleKey(key)) throw new TypeError(`Rule "${name}": params can't use the reserved key "${key}"`);
+	for (const [name, rule] of Object.entries(registry.formRules)) for (const key of Object.keys(rule.params?.entries ?? {})) if (isReservedFormRuleKey(key)) throw new TypeError(`Form rule "${name}": params can't use the reserved key "${key}"`);
 	for (const [name, type] of Object.entries(registry.fieldTypes)) {
 		const at = `Field type "${name}"`;
 		for (const kind of [type.kind, type.itemKind]) if (typeof kind === "string" && !lookup(registry.kinds, kind)) throw new TypeError(`${at}: kind "${kind}" is not registered`);
+		if (type.container && type.kind !== "object" && type.kind !== "array") throw new TypeError(`${at}: a container's kind must be 'object' or 'array'`);
 		if (type.kind !== "none" && !type.schema) throw new TypeError(`${at}: schema() is required unless the kind is 'none'`);
 		for (const key of Object.keys(type.props?.entries ?? {})) if (isReservedFieldKey(key)) throw new TypeError(`${at}: props can't use the reserved key "${key}"`);
 		if (typeof type.kind === "string" && typeof type.itemKind !== "function") checkDefaultRules(name, type, {
@@ -1034,6 +1135,293 @@ function toIssues(code, path, valibotIssues) {
 		return issue(code, [...path, ...keys], valibotIssue.message);
 	});
 }
+// src/builder/check-form-rules.ts
+const ruleShape = v.looseObject({
+	rule: v.string(),
+	field: v.string(),
+	message: v.string()
+});
+/**
+* Checks the definition's form rules against the fields the compiler built, and adds their
+* issues to `issues`. Returns the rules that are ready to build.
+*/
+function checkFormRules(rules, registry, fieldsByPath, issues) {
+	return rules.flatMap((raw, i) => checkFormRule(raw, ["formRules", i], registry, fieldsByPath, issues) ?? []);
+}
+function checkFormRule(raw, path, registry, fieldsByPath, issues) {
+	const shape = v.safeParse(ruleShape, raw);
+	if (!shape.success) {
+		issues.push(...toIssues("invalid_shape", path, shape.issues));
+		return;
+	}
+	const rule = shape.output;
+	const at = `Form rule "${rule.rule}"`;
+	const def = lookup(registry.formRules, rule.rule);
+	if (!def) {
+		issues.push(issue("unknown_rule", [...path, "rule"], `Unknown form rule "${rule.rule}"`));
+		return;
+	}
+	const params = checkParams(rule, def.params, isReservedFormRuleKey, at, path, issues);
+	if (!params) return void 0;
+	const dotPaths = [rule.field, ...def.reads(params)];
+	const paths = dotPaths.map((dotPath) => dotPath.split("."));
+	const fieldKeys = paths[0];
+	const issueCount = issues.length;
+	const fields = dotPaths.map((dotPath, i) => {
+		const found = findField(dotPath, fieldsByPath);
+		const message = typeof found === "string" ? found : i > 0 && outsideItem(paths[i], fieldKeys);
+		if (!message) return found;
+		issues.push(issue("unknown_field", i === 0 ? [...path, "field"] : path, message));
+		return null;
+	});
+	if (issues.length > issueCount) return void 0;
+	if (fields.some((field) => !field)) return void 0;
+	const checked = fields;
+	const kinds = checked.map((field) => field.valueKind);
+	const wrong = kinds.find((kind) => def.kinds && !def.kinds.includes(kind));
+	if (wrong !== void 0) {
+		const message = `${at} can't be used on ${wrong} fields`;
+		issues.push(issue("kind_mismatch", [...path, "rule"], message));
+		return;
+	}
+	if (def.sameKind && new Set(kinds).size > 1) {
+		const message = `${at} needs fields of one kind, not ${[...new Set(kinds)].join(" and ")}`;
+		issues.push(issue("kind_mismatch", [...path, "rule"], message));
+		return;
+	}
+	const field = checked[0].field;
+	return {
+		name: rule.rule,
+		def,
+		params,
+		message: rule.message,
+		path,
+		field,
+		paths
+	};
+}
+/**
+* The field with a value at `dotPath`. Null when a field on the way has issues of its own, and
+* the issue's message when there is no such field.
+*/
+function findField(dotPath, fieldsByPath) {
+	const keys = dotPath.split(".");
+	let found;
+	for (let i = 1; i <= keys.length; i++) {
+		found = fieldsByPath.get(keys.slice(0, i).join("."));
+		if (found === null) return null;
+		if (found) continue;
+		if (keys[i - 1] === "*" && i < keys.length) continue;
+		if (fieldsByPath.get(keys.slice(0, i - 1).join("."))?.valueKind === "array" && keys[i - 1] !== "*") return `Unknown field "${dotPath}". A list's items are read with "*": "${[
+			...keys.slice(0, i - 1),
+			"*",
+			...keys.slice(i - 1)
+		].join(".")}"`;
+		return `Unknown field "${dotPath}"`;
+	}
+	return found ?? `Unknown field "${dotPath}"`;
+}
+/**
+* A path into the items of a list is read once per item, so `field` must be in the same items.
+* Returns the issue's message when it isn't.
+*/
+function outsideItem(keys, fieldKeys) {
+	const star = keys.lastIndexOf("*");
+	const item = (path) => path.slice(0, star + 1).join(".");
+	if (star === -1 || item(keys) === item(fieldKeys)) return void 0;
+	const list = keys.slice(0, star).join(".");
+	return `"${keys.join(".")}" is read from each item of "${list}", so "${fieldKeys.join(".")}" must be too`;
+}
+// src/builder/form-rule-action.ts
+/**
+* Runs a form rule on the form's value and puts its issue on `field`. A rule on the fields of a
+* list's items runs once per item, with the item's index in place of each `'*'`.
+*
+* The rule only runs when none of the fields it reads has an issue. `v.partialCheck` can't do
+* this: it runs whenever the form has no schema issues, even when a field it reads failed a rule.
+*/
+function formRuleAction(rule, message) {
+	const { def, params, paths } = rule;
+	const fieldKeys = paths[0];
+	return v.rawCheck(({ dataset, addIssue }) => {
+		for (const indexes of itemIndexes(dataset.value, fieldKeys)) {
+			const read = paths.map((keys) => withIndexes(keys, indexes));
+			if (read.some((path) => hasIssue(dataset.issues, path))) continue;
+			const values = read.map((path) => valueAt(dataset.value, path));
+			if (values.includes(void 0) || def.check(values, params)) continue;
+			const field = read[0];
+			addIssue({
+				message,
+				input: values[0],
+				path: issuePath(dataset.value, field)
+			});
+		}
+	});
+}
+/** Replaces each `'*'` in `keys` with the next index. */
+const withIndexes = (keys, indexes) => {
+	let next = 0;
+	return keys.map((key) => key === "*" ? indexes[next++] : key);
+};
+const valueAt = (input, path) => path.reduce((value, key) => typeof value === "object" && value !== null ? value[key] : void 0, input);
+/** True when an issue is on `path`, inside it, or on a value that holds it. */
+const hasIssue = (issues, path) => !!issues?.some((issue) => (issue.path ?? []).every((item, i) => i >= path.length || item.key === path[i]));
+/** Valibot's path to `path` in `input`, the way an object or array schema reports it. */
+const issuePath = (input, path) => path.map((key, i) => {
+	const parent = valueAt(input, path.slice(0, i));
+	return {
+		type: Array.isArray(parent) ? "array" : "object",
+		origin: "value",
+		input: parent,
+		key,
+		value: valueAt(parent, [key])
+	};
+});
+/** The indexes for each `'*'` in `keys`, for every item `value` has there. */
+function* itemIndexes(value, keys, indexes = []) {
+	const star = keys.indexOf("*");
+	if (star === -1) {
+		yield indexes;
+		return;
+	}
+	const list = valueAt(value, keys.slice(0, star));
+	if (!Array.isArray(list)) return;
+	for (const [i, item] of list.entries()) yield* itemIndexes(item, keys.slice(star + 1), [...indexes, i]);
+}
+// src/builder/compile-definition.ts
+const formShape = v.object({
+	version: v.string(),
+	fields: v.array(v.unknown()),
+	formRules: v.optional(v.array(v.unknown()))
+});
+/**
+* Checks a definition and builds its schema in the same pass, so `validate()` and `build()`
+* always agree. Never throws on bad input.
+*/
+function compileDefinition(json, registry, messages) {
+	const issues = [];
+	const form = v.safeParse(formShape, json);
+	if (!form.success) return {
+		issues: toIssues("invalid_shape", [], form.issues),
+		schema: v.object({})
+	};
+	if (form.output.version !== "1") {
+		const message = `Unsupported version "${form.output.version}". This package reads version '1'.`;
+		issues.push({
+			code: "unsupported_version",
+			path: ["version"],
+			message
+		});
+		return {
+			issues,
+			schema: v.object({})
+		};
+	}
+	const compiler = createCompiler(registry, messages, issues);
+	const schema = compiler.fields(form.output.fields, ["fields"]);
+	const rules = checkFormRules(form.output.formRules ?? [], registry, compiler.fieldsByPath, issues);
+	if (issues.length || !rules.length) return {
+		issues,
+		schema
+	};
+	return {
+		issues,
+		schema: rules.reduce((acc, rule) => {
+			const ctx = {
+				field: rule.field,
+				rule: rule.name,
+				path: rule.path
+			};
+			return v.pipe(acc, formRuleAction(rule, messages.resolve(rule.message, ctx)));
+		}, schema)
+	};
+}
+/** Every field the compiler checks adds its issues to `issues`. */
+function createCompiler(registry, messages, issues) {
+	const context = (path) => ({
+		path,
+		buildFields: fields,
+		buildField: field
+	});
+	const fieldsByPath = /* @__PURE__ */ new Map();
+	const parents = [];
+	const parentPath = () => parents.at(-1) ?? [];
+	function fields(list, path) {
+		const entries = {};
+		const names = /* @__PURE__ */ new Set();
+		list.forEach((raw, i) => {
+			const checked = checkField(raw, [...path, i], registry, names, issues);
+			const name = checked ? checked.name : nameOf(raw);
+			if (name === void 0) return;
+			const dataPath = [...parentPath(), name];
+			remember(raw, checked, dataPath);
+			if (checked) entries[name] = build(checked, dataPath);
+		});
+		return v.object(entries);
+	}
+	function field(raw, path) {
+		const checked = checkField(raw, path, registry, void 0, issues);
+		const dataPath = parentPath();
+		remember(raw, checked, dataPath);
+		return checked ? build(checked, dataPath) : v.never();
+	}
+	function build(checked, dataPath) {
+		parents.push(checked.valueKind === "array" ? [...dataPath, "*"] : dataPath);
+		try {
+			const schema = buildFieldSchema(checked, messages, context(checked.path));
+			checkDefault(checked, schema, issues);
+			return schema;
+		} finally {
+			parents.pop();
+		}
+	}
+	/** The first field at a path wins, as with duplicate names. Display elements are left out. */
+	function remember(raw, checked, dataPath) {
+		const key = dataPath.join(".");
+		if (fieldsByPath.has(key) || !checked && !hasValue(raw, registry)) return;
+		fieldsByPath.set(key, checked ?? null);
+	}
+	return {
+		fields,
+		field,
+		fieldsByPath
+	};
+}
+const isRecord = (value) => typeof value === "object" && value !== null;
+const nameOf = (raw) => isRecord(raw) && typeof raw.name === "string" ? raw.name : void 0;
+/** An unknown type counts as one with a value, so a form rule that reads the field is fine. */
+const hasValue = (raw, registry) => isRecord(raw) && typeof raw.type === "string" && lookup(registry.fieldTypes, raw.type)?.kind !== "none";
+/** A default must be a value the field accepts. An empty one is the same as none. */
+function checkDefault({ field, kind, path }, schema, issues) {
+	if (field.default === void 0 || kind.isEmpty(field.default)) return;
+	const result = v.safeParse(schema, field.default);
+	if (!result.success) issues.push(...toIssues("invalid_default", [...path, "default"], result.issues));
+}
+// src/builder/build-context.ts
+const messages = {
+	required: "Required",
+	resolve: (text) => text
+};
+/**
+* A build context for testing a field type on its own, without a definition around it.
+* `buildFields` and `buildField` use the default registries and throw a `DefinitionError` when
+* the child fields have issues. `overrides` replaces any member, e.g. `path`.
+*/
+function createBuildContext(overrides = {}) {
+	const registry = mergeRegistry({});
+	const run = (compile) => {
+		const issues = [];
+		const result = compile(createCompiler(registry, messages, issues));
+		if (issues.length) throw new DefinitionError(issues);
+		return result;
+	};
+	return {
+		path: [],
+		buildFields: (fields, path) => run((compiler) => compiler.fields(fields, path)),
+		buildField: (field, path) => run((compiler) => compiler.field(field, path)),
+		...overrides
+	};
+}
 // src/builder/create-schema-builder.ts
 function createSchemaBuilder(options = {}) {
 	const registry = mergeRegistry(options);
@@ -1044,7 +1432,7 @@ function createSchemaBuilder(options = {}) {
 	};
 	/** Every issue in the definition, in document order. Never throws on bad input. */
 	function validate(json) {
-		const { issues } = checkDefinition(json, registry);
+		const { issues } = compileDefinition(json, registry, messages);
 		return issues.length ? {
 			success: false,
 			issues
@@ -1054,11 +1442,9 @@ function createSchemaBuilder(options = {}) {
 		};
 	}
 	function build(json) {
-		const { issues, fields } = checkDefinition(json, registry);
+		const { issues, schema } = compileDefinition(json, registry, messages);
 		if (issues.length) throw new DefinitionError(issues);
-		const entries = {};
-		for (const field of fields) entries[field.name] = buildFieldSchema(field, messages);
-		return v.object(entries);
+		return schema;
 	}
 	/**
 	* The registered rules that can be used on a field of `kind`, e.g. for a rule picker.
@@ -1072,9 +1458,66 @@ function createSchemaBuilder(options = {}) {
 		rulesForKind,
 		kinds: registry.kinds,
 		fieldTypes: registry.fieldTypes,
-		rules: registry.rules
+		rules: registry.rules,
+		formRules: registry.formRules
 	};
 }
-export { DefinitionError, RESERVED_FIELD_KEYS, RESERVED_RULE_KEYS, comparisonRules, contentRules, createSchemaBuilder, dateRules, defaultFieldTypes, defaultKinds, defaultRules, defineFieldType, defineRule, fileRules, formatPath, formatRules, lengthRules, normalizeRules, numberRules, textUnitRules };
+// src/definition/initial-input.ts
+/**
+* Formisch's `initialInput` for a definition: each field's `default`, nested the way the value
+* is. A group gives an object, and an array without a default gives `[]`. Other fields without
+* a default are left out. Like `walkFields`, it reads the built-in `group` and `array` types
+* and needs no builder.
+*/
+function getInitialInput(definition) {
+	return inputOf(definition.fields);
+}
+function inputOf(fields) {
+	const input = {};
+	for (const field of fields) {
+		if (field.name === void 0) continue;
+		const value = initialValue(field);
+		if (value !== void 0) input[field.name] = value;
+	}
+	return input;
+}
+function initialValue(field) {
+	if (field.type === "group") return inputOf(Array.isArray(field.fields) ? field.fields : []);
+	if (field.type === "array") return field.default ?? [];
+	return field.default;
+}
+// src/definition/walk-fields.ts
+/**
+* Every field of a definition, at every depth, in document order. A group or an array comes
+* before its fields, and the fields of an array's items come once. It reads the built-in
+* `group` and `array` types and needs no builder, so it doesn't check the definition: run
+* `validate()` first.
+*/
+function* walkFields(definition) {
+	yield* walkList(definition.fields, ["fields"], [], 0);
+}
+function* walkList(fields, at, dataPath, depth) {
+	for (const [i, field] of fields.entries()) {
+		const path = field.name === void 0 ? dataPath : [...dataPath, field.name];
+		yield* walkField(field, [...at, i], path, depth);
+	}
+}
+function* walkField(field, definitionPath, dataPath, depth) {
+	yield {
+		field,
+		type: field.type,
+		dataPath,
+		definitionPath,
+		depth
+	};
+	if (field.type === "group" && Array.isArray(field.fields)) yield* walkList(field.fields, [...definitionPath, "fields"], dataPath, depth + 1);
+	else if (field.type === "array") {
+		const items = [...dataPath, "*"];
+		if (isField(field.of)) yield* walkField(field.of, [...definitionPath, "of"], items, depth + 1);
+		else if (Array.isArray(field.fields)) yield* walkList(field.fields, [...definitionPath, "fields"], items, depth + 1);
+	}
+}
+const isField = (value) => typeof value === "object" && value !== null && "type" in value;
+export { DefinitionError, RESERVED_FIELD_KEYS, RESERVED_FORM_RULE_KEYS, RESERVED_RULE_KEYS, comparisonRules, contentRules, createBuildContext, createSchemaBuilder, dateRules, defaultFieldTypes, defaultFormRules, defaultKinds, defaultRules, defineFieldType, defineFormRule, defineRule, fileRules, formatPath, formatRules, getInitialInput, lengthRules, normalizeRules, numberRules, textUnitRules, walkFields };
 
 //# sourceMappingURL=index.js.map