@whatsaaaa/form-builder-schema 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,124 +1,884 @@
 import * as v from "valibot";
-// src/field-types.ts
+// src/builder/build-field-schema.ts
+/**
+* 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.
+*/
+function buildFieldSchema(checked, messages) {
+	const { field, path, type, kind } = checked;
+	const required = !!field.required;
+	const requiredMessage = messages.resolve(typeof field.required === "object" && field.required.message || messages.required, {
+		field,
+		path
+	});
+	const normalize = [];
+	const validate = [];
+	for (const rule of checked.rules) {
+		const message = rule.message === void 0 ? void 0 : messages.resolve(rule.message, {
+			field,
+			rule: rule.name,
+			path
+		});
+		const action = rule.def.create(rule.params, message);
+		if (rule.def.stage === "normalize") normalize.push(action);
+		else validate.push(action);
+	}
+	const base = type.schema(field, { path });
+	const requiredCheck = required ? kind.required?.(requiredMessage) : void 0;
+	const head = pipe(base, requiredCheck ? [...normalize, requiredCheck] : normalize);
+	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(), validate))));
+	return required ? schema : v.optional(schema);
+}
+const pipe = (schema, actions) => actions.reduce((acc, action) => v.pipe(acc, action), schema);
+// src/field-types/default-field-types.ts
 const defaultFieldTypes = {
 	text: {
 		kind: "string",
-		base: (m) => v.string(m)
+		schema: () => v.string()
 	},
 	password: {
 		kind: "string",
-		base: (m) => v.string(m)
+		schema: () => v.string()
 	},
 	email: {
 		kind: "string",
-		base: (m) => v.string(m),
-		defaultRules: [{
-			rule: "email",
-			message: "Invalid email"
-		}]
+		schema: () => v.string(),
+		defaultRules: [{ rule: "email" }]
 	},
 	number: {
 		kind: "number",
-		base: (m) => v.number(m)
+		schema: () => v.number()
 	}
 };
-// src/rules.ts
+// src/kinds/default-kinds.ts
+const isNil = (input) => input === void 0 || input === null;
+const defaultKinds = {
+	string: {
+		isEmpty: (input) => isNil(input) || input === "",
+		required: (message) => v.nonEmpty(message)
+	},
+	number: { isEmpty: (input) => isNil(input) || input === "" || Number.isNaN(input) },
+	boolean: {
+		isEmpty: isNil,
+		required: (message) => v.value(true, message)
+	},
+	date: {
+		isEmpty: (input) => isNil(input) || input === "",
+		required: (message) => v.nonEmpty(message)
+	},
+	array: {
+		isEmpty: (input) => isNil(input) || Array.isArray(input) && input.length === 0,
+		required: (message) => v.minLength(1, message)
+	},
+	file: { isEmpty: isNil },
+	object: { isEmpty: isNil },
+	none: { isEmpty: () => true }
+};
+// src/rules/define-rule.ts
 const defineRule = (def) => def;
-const nonNegInt = v.pipe(v.number(), v.integer(), v.minValue(0));
-const noParams = v.object({});
-const defaultRules = {
-	minLength: defineRule({
+// src/rules/param-schemas.ts
+/** A length, count or size: a whole number from 0. */
+const count = v.pipe(v.number(), v.integer(), v.minValue(0));
+const countParams = v.object({ value: count });
+const isIsoValue = (input) => v.ISO_DATE_REGEX.test(input) || v.ISO_DATE_TIME_REGEX.test(input) || v.ISO_TIME_REGEX.test(input);
+/** Valibot compares dates as ISO strings, so the param must be one too. */
+const isoValue = v.pipe(v.string(), v.check(isIsoValue, "Use an ISO date, date-time or time, such as 2026-01-01"));
+const valueSchema = (kind) => {
+	switch (kind) {
+		case "date": return isoValue;
+		case "string": return v.string();
+		case "boolean": return v.boolean();
+		default: return v.number();
+	}
+};
+// src/rules/comparison-rules.ts
+const ordered = ["number", "date"];
+const any = [
+	"number",
+	"date",
+	"string",
+	"boolean"
+];
+const meta$6 = (label) => ({
+	label,
+	category: "comparison"
+});
+const valueParams = (kind) => v.object({ value: valueSchema(kind) });
+const valuesParams = (kind) => v.object({ values: v.pipe(v.array(valueSchema(kind)), v.minLength(1, "Give at least one value")) });
+/** Compares the value with a param of the same type. */
+const comparisonRules = {
+	minValue: defineRule({
+		kinds: ordered,
+		params: valueParams,
+		meta: meta$6("Minimum"),
+		create: (p, m) => v.minValue(p.value, m)
+	}),
+	maxValue: defineRule({
+		kinds: ordered,
+		params: valueParams,
+		meta: meta$6("Maximum"),
+		create: (p, m) => v.maxValue(p.value, m)
+	}),
+	gtValue: defineRule({
+		kinds: ordered,
+		params: valueParams,
+		meta: meta$6("Greater than"),
+		create: (p, m) => v.gtValue(p.value, m)
+	}),
+	ltValue: defineRule({
+		kinds: ordered,
+		params: valueParams,
+		meta: meta$6("Less than"),
+		create: (p, m) => v.ltValue(p.value, m)
+	}),
+	value: defineRule({
+		kinds: any,
+		params: valueParams,
+		meta: meta$6("Equals"),
+		create: (p, m) => v.value(p.value, m)
+	}),
+	notValue: defineRule({
+		kinds: any,
+		params: valueParams,
+		meta: meta$6("Does not equal"),
+		create: (p, m) => v.notValue(p.value, m)
+	}),
+	values: defineRule({
+		kinds: ordered,
+		params: valuesParams,
+		meta: meta$6("One of"),
+		create: (p, m) => v.values(p.values, m)
+	}),
+	notValues: defineRule({
+		kinds: ordered,
+		params: valuesParams,
+		meta: meta$6("None of"),
+		create: (p, m) => v.notValues(p.values, m)
+	})
+};
+// src/rules/content-rules.ts
+const meta$5 = (label, description) => ({
+	label,
+	description,
+	category: "content"
+});
+const regexError = (pattern, flags = "") => {
+	try {
+		new RegExp(pattern, flags);
+		return;
+	} catch (error) {
+		return error.message;
+	}
+};
+const FLAGS = /^[dgimsuvy]*$/;
+const regexParams = v.pipe(v.object({
+	pattern: v.string(),
+	flags: v.optional(v.pipe(v.string(), v.regex(FLAGS, "Flags can be d, g, i, m, s, u, v and y")))
+}), v.forward(v.check((p) => !FLAGS.test(p.flags ?? "") || regexError(p.pattern, p.flags) === void 0, (issue) => regexError(issue.input.pattern, issue.input.flags) ?? "Invalid pattern"), ["pattern"]));
+const item = v.union([
+	v.string(),
+	v.number(),
+	v.boolean()
+]);
+const stringParams = v.object({ value: v.string() });
+const contentParams = (kind) => v.object({ value: kind === "array" ? item : v.string() });
+const contentRules = {
+	regex: defineRule({
+		kinds: ["string"],
+		params: regexParams,
+		meta: meta$5("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"),
+		create: (p, m) => v.startsWith(p.value, m)
+	}),
+	endsWith: defineRule({
+		kinds: ["string"],
+		params: stringParams,
+		meta: meta$5("Ends with"),
+		create: (p, m) => v.endsWith(p.value, m)
+	}),
+	includes: defineRule({
+		kinds: ["string", "array"],
+		params: contentParams,
+		meta: meta$5("Contains"),
+		create: (p, m) => v.includes(p.value, m)
+	}),
+	excludes: defineRule({
+		kinds: ["string", "array"],
+		params: contentParams,
+		meta: meta$5("Does not contain"),
+		create: (p, m) => v.excludes(p.value, m)
+	})
+};
+// src/rules/date-rules.ts
+const iso = (label, description, create) => defineRule({
+	kinds: ["string", "date"],
+	meta: {
+		label,
+		description,
+		category: "date"
+	},
+	create: (_, message) => create(message)
+});
+const dateRules = {
+	isoDate: iso("ISO date", "Like 2026-10-28", (m) => v.isoDate(m)),
+	isoDateTime: iso("ISO date and time", "Like 2026-10-28T14:30", (m) => v.isoDateTime(m)),
+	isoTime: iso("ISO time", "Like 14:30", (m) => v.isoTime(m)),
+	isoTimeSecond: iso("ISO time with seconds", "Like 14:30:15", (m) => v.isoTimeSecond(m)),
+	isoTimestamp: iso("ISO timestamp", "Like 2026-10-28T14:30:15.000z", (m) => v.isoTimestamp(m)),
+	isoWeek: iso("ISO week", "Like 2026-W44", (m) => v.isoWeek(m))
+};
+// src/rules/file-rules.ts
+const kinds$3 = ["file"];
+const meta$4 = (label, description) => ({
+	label,
+	description,
+	category: "file"
+});
+const bytes = "In bytes, e.g. 1048576 for 1 MiB.";
+const mimeTypeParams = v.object({ types: v.pipe(v.array(v.pipe(v.string(), v.regex(/^[\w.+-]+\/[\w.+-]+$/, "Use a MIME type, such as image/png"))), v.minLength(1, "Give at least one MIME type")) });
+/** Size and type of a File or Blob. */
+const fileRules = {
+	minSize: defineRule({
+		kinds: kinds$3,
+		params: countParams,
+		meta: meta$4("Minimum size", bytes),
+		create: (p, m) => v.minSize(p.value, m)
+	}),
+	maxSize: defineRule({
+		kinds: kinds$3,
+		params: countParams,
+		meta: meta$4("Maximum size", bytes),
+		create: (p, m) => v.maxSize(p.value, m)
+	}),
+	size: defineRule({
+		kinds: kinds$3,
+		params: countParams,
+		meta: meta$4("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),
+		create: (p, m) => v.notSize(p.value, m)
+	}),
+	mimeType: defineRule({
+		kinds: kinds$3,
+		params: mimeTypeParams,
+		meta: meta$4("File type"),
+		create: (p, m) => v.mimeType(p.types, m)
+	})
+};
+// src/rules/format-rules.ts
+/** A string format without params. */
+const format = (label, create) => defineRule({
+	kinds: ["string"],
+	meta: {
+		label,
+		category: "format"
+	},
+	create: (_, message) => create(message)
+});
+const hashParams = v.object({ types: v.pipe(v.array(v.picklist([
+	"md4",
+	"md5",
+	"sha1",
+	"sha256",
+	"sha384",
+	"sha512",
+	"ripemd128",
+	"ripemd160",
+	"tiger128",
+	"tiger160",
+	"tiger192",
+	"crc32",
+	"crc32b",
+	"adler32"
+])), v.minLength(1, "Pick at least one hash type")) });
+/** Formats Valibot can check on a string. */
+const formatRules = {
+	email: format("Email", (m) => v.email(m)),
+	rfcEmail: format("Email (RFC 5322)", (m) => v.rfcEmail(m)),
+	url: format("URL", (m) => v.url(m)),
+	domain: format("Domain", (m) => v.domain(m)),
+	slug: format("Slug", (m) => v.slug(m)),
+	uuid: format("UUID", (m) => v.uuid(m)),
+	ulid: format("ULID", (m) => v.ulid(m)),
+	cuid2: format("CUID2", (m) => v.cuid2(m)),
+	nanoid: format("Nano ID", (m) => v.nanoid(m)),
+	ip: format("IP address", (m) => v.ip(m)),
+	ipv4: format("IPv4 address", (m) => v.ipv4(m)),
+	ipv6: format("IPv6 address", (m) => v.ipv6(m)),
+	mac: format("MAC address", (m) => v.mac(m)),
+	mac48: format("MAC-48 address", (m) => v.mac48(m)),
+	mac64: format("MAC-64 address", (m) => v.mac64(m)),
+	hexColor: format("Hex colour", (m) => v.hexColor(m)),
+	hexadecimal: format("Hexadecimal", (m) => v.hexadecimal(m)),
+	octal: format("Octal", (m) => v.octal(m)),
+	decimal: format("Decimal number", (m) => v.decimal(m)),
+	digits: format("Digits only", (m) => v.digits(m)),
+	base64: format("Base64", (m) => v.base64(m)),
+	bic: format("BIC (SWIFT code)", (m) => v.bic(m)),
+	creditCard: format("Credit card number", (m) => v.creditCard(m)),
+	imei: format("IMEI", (m) => v.imei(m)),
+	isbn: format("ISBN", (m) => v.isbn(m)),
+	isrc: format("ISRC", (m) => v.isrc(m)),
+	emoji: format("Emoji", (m) => v.emoji(m)),
+	hash: defineRule({
 		kinds: ["string"],
-		params: v.object({ value: nonNegInt }),
+		params: hashParams,
+		meta: {
+			label: "Hash",
+			category: "format"
+		},
+		create: (p, m) => v.hash(p.types, m)
+	})
+};
+// src/rules/length-rules.ts
+const kinds$2 = ["string", "array"];
+const meta$3 = (label) => ({
+	label,
+	category: "length"
+});
+/** Characters of a string, or items of an array */
+const lengthRules = {
+	length: defineRule({
+		kinds: kinds$2,
+		params: countParams,
+		meta: meta$3("Exact length"),
+		create: (p, m) => v.length(p.value, m)
+	}),
+	minLength: defineRule({
+		kinds: kinds$2,
+		params: countParams,
+		meta: meta$3("Minimum length"),
 		create: (p, m) => v.minLength(p.value, m)
 	}),
 	maxLength: defineRule({
-		kinds: ["string"],
-		params: v.object({ value: nonNegInt }),
+		kinds: kinds$2,
+		params: countParams,
+		meta: meta$3("Maximum length"),
 		create: (p, m) => v.maxLength(p.value, m)
 	}),
-	regex: defineRule({
+	notLength: defineRule({
+		kinds: kinds$2,
+		params: countParams,
+		meta: meta$3("Not this length"),
+		create: (p, m) => v.notLength(p.value, m)
+	})
+};
+// src/rules/normalize-rules.ts
+const stage = "normalize";
+const meta$2 = (label, description) => ({
+	label,
+	description,
+	category: "normalize"
+});
+const limit = v.object({ value: v.number() });
+/**
+* Rules that change the value instead of checking it. They run before the required check, so
+* `'   '` with `trim` is empty. Their `message` is never shown.
+*/
+const normalizeRules = {
+	trim: defineRule({
 		kinds: ["string"],
-		params: v.object({
-			pattern: v.string(),
-			flags: v.optional(v.string())
-		}),
-		create: (p, m) => v.regex(new RegExp(p.pattern, p.flags), m)
+		stage,
+		meta: meta$2("Trim"),
+		create: () => v.trim()
 	}),
-	email: defineRule({
+	trimStart: defineRule({
 		kinds: ["string"],
-		params: noParams,
-		create: (_, m) => v.email(m)
+		stage,
+		meta: meta$2("Trim start"),
+		create: () => v.trimStart()
 	}),
-	url: defineRule({
+	trimEnd: defineRule({
 		kinds: ["string"],
-		params: noParams,
-		create: (_, m) => v.url(m)
+		stage,
+		meta: meta$2("Trim end"),
+		create: () => v.trimEnd()
 	}),
-	minValue: defineRule({
-		kinds: ["number"],
-		params: v.object({ value: v.number() }),
-		create: (p, m) => v.minValue(p.value, m)
+	toLowerCase: defineRule({
+		kinds: ["string"],
+		stage,
+		meta: meta$2("Lowercase"),
+		create: () => v.toLowerCase()
 	}),
-	maxValue: defineRule({
+	toUpperCase: defineRule({
+		kinds: ["string"],
+		stage,
+		meta: meta$2("Uppercase"),
+		create: () => v.toUpperCase()
+	}),
+	normalize: defineRule({
+		kinds: ["string"],
+		stage,
+		params: v.object({ form: v.optional(v.picklist([
+			"NFC",
+			"NFD",
+			"NFKC",
+			"NFKD"
+		])) }),
+		meta: meta$2("Unicode normalize", "Defaults to NFC."),
+		create: (p) => v.normalize(p.form)
+	}),
+	toMinValue: defineRule({
 		kinds: ["number"],
-		params: v.object({ value: v.number() }),
-		create: (p, m) => v.maxValue(p.value, m)
+		stage,
+		params: limit,
+		meta: meta$2("Raise to minimum", "Replaces a smaller number with the minimum."),
+		create: (p) => v.toMinValue(p.value)
 	}),
-	integer: defineRule({
+	toMaxValue: defineRule({
 		kinds: ["number"],
-		params: noParams,
+		stage,
+		params: limit,
+		meta: meta$2("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) => ({
+	label,
+	category: "number"
+});
+const divisor = v.pipe(v.number(), v.finite(), v.notValue(0, "Can't be 0"));
+/** Checks only numbers have. */
+const numberRules = {
+	integer: defineRule({
+		kinds: kinds$1,
+		meta: meta$1("Whole number"),
 		create: (_, m) => v.integer(m)
+	}),
+	safeInteger: defineRule({
+		kinds: kinds$1,
+		meta: meta$1("Safe whole number"),
+		create: (_, m) => v.safeInteger(m)
+	}),
+	finite: defineRule({
+		kinds: kinds$1,
+		meta: meta$1("Finite number"),
+		create: (_, m) => v.finite(m)
+	}),
+	multipleOf: defineRule({
+		kinds: kinds$1,
+		params: v.object({ value: divisor }),
+		meta: meta$1("Multiple of"),
+		create: (p, m) => v.multipleOf(p.value, m)
+	})
+};
+// src/rules/text-unit-rules.ts
+const kinds = ["string"];
+const meta = (label, description) => ({
+	label,
+	description,
+	category: "text"
+});
+const isLocale = (input) => {
+	try {
+		return Intl.getCanonicalLocales(input).length === 1;
+	} catch {
+		return false;
+	}
+};
+const wordsParams = v.object({
+	locale: v.optional(v.pipe(v.string(), v.check(isLocale, "Use a language tag, such as en or sr-Latn"))),
+	value: count
+});
+const graphemesInfo = "Counts characters as people see them, so an emoji is one.";
+const bytesInfo = "Counts UTF-8 bytes, e.g. to fit a database column,";
+const textUnitRules = {
+	graphemes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Exact characters", graphemesInfo),
+		create: (p, m) => v.graphemes(p.value, m)
+	}),
+	minGraphemes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Minimum characters", graphemesInfo),
+		create: (p, m) => v.minGraphemes(p.value, m)
+	}),
+	maxGraphemes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Maximum characters", graphemesInfo),
+		create: (p, m) => v.maxGraphemes(p.value, m)
+	}),
+	notGraphemes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Not this many characters", graphemesInfo),
+		create: (p, m) => v.notGraphemes(p.value, m)
+	}),
+	words: defineRule({
+		kinds,
+		params: wordsParams,
+		meta: meta("Exact words"),
+		create: (p, m) => v.words(p.locale, p.value, m)
+	}),
+	minWords: defineRule({
+		kinds,
+		params: wordsParams,
+		meta: meta("Minimum words"),
+		create: (p, m) => v.minWords(p.locale, p.value, m)
+	}),
+	maxWords: defineRule({
+		kinds,
+		params: wordsParams,
+		meta: meta("Maximum words"),
+		create: (p, m) => v.maxWords(p.locale, p.value, m)
+	}),
+	notWords: defineRule({
+		kinds,
+		params: wordsParams,
+		meta: meta("Not this many words"),
+		create: (p, m) => v.notWords(p.locale, p.value, m)
+	}),
+	bytes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Exact bytes", bytesInfo),
+		create: (p, m) => v.bytes(p.value, m)
+	}),
+	minBytes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Minimum bytes", bytesInfo),
+		create: (p, m) => v.minBytes(p.value, m)
+	}),
+	maxBytes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Maximum bytes", bytesInfo),
+		create: (p, m) => v.maxBytes(p.value, m)
+	}),
+	notBytes: defineRule({
+		kinds,
+		params: countParams,
+		meta: meta("Not this many bytes", bytesInfo),
+		create: (p, m) => v.notBytes(p.value, m)
 	})
 };
-// src/create-schema-builder.ts
-function createSchemaBuilder(opts = {}) {
-	const fieldTypes = {
-		...defaultFieldTypes,
-		...opts.fieldTypes
+// src/rules/default-rules.ts
+/** Every built-in rule. Register single families with `includeDefaultRules: false`. */
+const defaultRules = {
+	...lengthRules,
+	...textUnitRules,
+	...contentRules,
+	...formatRules,
+	...dateRules,
+	...comparisonRules,
+	...numberRules,
+	...fileRules,
+	...normalizeRules
+};
+// src/builder/registry.ts
+/** Consumer entries replace defaults with the same key. */
+function mergeRegistry(custom) {
+	const rules = custom.includeDefaultRules === false ? {} : defaultRules;
+	return {
+		kinds: Object.freeze({
+			...defaultKinds,
+			...custom.kinds
+		}),
+		fieldTypes: Object.freeze({
+			...defaultFieldTypes,
+			...custom.fieldTypes
+		}),
+		rules: Object.freeze({
+			...rules,
+			...custom.rules
+		})
+	};
+}
+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) {
+	if (typeof def.params !== "function") return def.params;
+	let byKind = cache.get(def);
+	if (!byKind) {
+		byKind = /* @__PURE__ */ new Map();
+		cache.set(def, byKind);
+	}
+	let params = byKind.get(kind);
+	if (!params) {
+		params = def.params(kind);
+		byKind.set(kind, params);
+	}
+	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 own. 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(),
+	label: v.optional(v.string()),
+	description: v.optional(v.string()),
+	placeholder: v.optional(v.string()),
+	default: v.optional(v.unknown()),
+	required: v.optional(v.union([v.boolean(), v.strictObject({ message: v.optional(v.string()) })])),
+	rules: v.optional(v.array(v.unknown())),
+	ui: v.optional(v.record(v.string(), v.unknown()))
+});
+const ruleShape = 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.
+*/
+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
 	};
-	const rules = {
-		...defaultRules,
-		...opts.rules
+}
+function checkField(raw, path, registry, names, issues) {
+	const shape = v.safeParse(fieldShape, raw);
+	if (!shape.success) {
+		issues.push(...toIssues("invalid_shape", path, shape.issues));
+		return;
+	}
+	const field = shape.output;
+	const issueCount = issues.length;
+	const type = lookup(registry.fieldTypes, field.type);
+	const hasValue = type?.kind !== "none";
+	if (!field.name) {
+		if (type && hasValue) issues.push(issue("missing_name", [...path, "name"], "A field needs a name"));
+	} else if (hasValue) {
+		if (names.has(field.name)) issues.push(issue("duplicate_name", [...path, "name"], `Duplicate name "${field.name}"`));
+		names.add(field.name);
+	}
+	if (!type) {
+		issues.push(issue("unknown_type", [...path, "type"], `Unknown field type "${field.type}"`));
+		return;
+	}
+	const props = checkProps(field, type, path, issues);
+	if (!hasValue) {
+		for (const key of ["required", "rules"]) if (field[key] !== void 0) {
+			const message = `A "${field.type}" field has no value, so it can't have "${key}"`;
+			issues.push(issue("invalid_shape", [...path, key], message));
+		}
+		return;
+	}
+	const fieldRules = (shape.output.rules ?? []).flatMap((rule, j) => checkRule(rule, type?.kind, [
+		...path,
+		"rules",
+		j
+	], registry, issues) ?? []);
+	if (issues.length > issueCount || !field.name) return void 0;
+	const overridden = new Set(fieldRules.map((rule) => rule.name));
+	const defaultRules = (type?.defaultRules ?? []).filter((rule) => !overridden.has(rule.rule)).flatMap((rule) => checkRule(rule, type?.kind, path, registry, []) ?? []);
+	return {
+		name: field.name,
+		field: {
+			...field,
+			...props
+		},
+		path,
+		type,
+		kind: registry.kinds[type?.kind],
+		rules: [...defaultRules, ...fieldRules]
+	};
+}
+function checkProps(field, type, path, issues) {
+	const propKeys = Object.keys(type.props?.entries ?? {});
+	const input = {};
+	for (const key of Object.keys(field)) {
+		if (isReservedFieldKey(key)) continue;
+		if (propKeys.includes(key)) input[key] = field[key];
+		else issues.push(issue("unknown_key", [...path, key], `Unknown key "${key}" on a "${field.type}" field`));
+	}
+	if (!type.props) return {};
+	const parsed = v.safeParse(type.props, input);
+	if (parsed.success) return parsed.output;
+	issues.push(...toIssues("invalid_props", path, parsed.issues));
+	return {};
+}
+function checkRule(raw, kind, path, registry, issues) {
+	const shape = v.safeParse(ruleShape, raw);
+	if (!shape.success) {
+		issues.push(...toIssues("invalid_shape", path, shape.issues));
+		return;
+	}
+	const rule = shape.output;
+	const def = lookup(registry.rules, rule.rule);
+	if (!def) {
+		issues.push(issue("unknown_rule", [...path, "rule"], `Unknown rule "${rule.rule}"`));
+		return;
+	}
+	if (!def.kinds.includes(kind)) {
+		const message = `Rule "${rule.rule}" can't be used on ${kind} fields`;
+		issues.push(issue("kind_mismatch", [...path, "rule"], message));
+		return;
+	}
+	const issueCount = issues.length;
+	const params = paramsFor(def, 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}"`));
+	}
+	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
 	};
-	function buildAction(rule, kind, at) {
-		const def = rules[rule.rule];
-		if (!def) throw new Error(`${at}: unknown rule "${rule.rule}"`);
-		if (!def.kinds.includes(kind)) throw new Error(`${at}: rule "${rule.rule}" can't be used on ${kind} fields`);
-		const parsed = v.safeParse(def.params, rule);
-		if (!parsed.success) throw new Error(`${at}: invalid params for "${rule.rule}"\n${v.summarize(parsed.issues)}`);
-		return def.create(parsed.output, rule.message);
-	}
-	function buildField(field, i) {
-		const at = `fields[${i}] "${field.name}"`;
-		const type = fieldTypes[field.type];
-		if (!type) throw new Error(`${at}: unknown field type "${field.type}"`);
-		const userRules = field.rules ?? [];
-		const overridden = new Set(userRules.map((r) => r.rule));
-		const allRules = [...(type.defaultRules ?? []).filter((r) => !overridden.has(r.rule)), ...userRules];
-		const required = !!field.required;
-		const requiredMsg = typeof field.required === "object" ? field.required.message : void 0;
-		const actions = [];
-		if (required && type.kind === "string") actions.push(v.nonEmpty(requiredMsg ?? "Required"));
-		allRules.forEach((r, j) => {
-			actions.push(buildAction(r, type.kind, `${at}.rules[${j}]`));
+}
+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, type] of Object.entries(registry.fieldTypes)) {
+		const at = `Field type "${name}"`;
+		if (!lookup(registry.kinds, type.kind)) throw new TypeError(`${at}: kind "${type.kind}" is not registered`);
+		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}"`);
+		const issues = [];
+		type.defaultRules?.forEach((rule, j) => {
+			checkRule(rule, type.kind, ["defaultRules", j], registry, issues);
 		});
-		const baseMsg = required && type.kind === "number" ? requiredMsg ?? "Required" : requiredMsg;
-		const schema = actions.reduce((s, a) => v.pipe(s, a), type.base(baseMsg));
-		if (required) return schema;
-		if (type.kind === "string") return v.optional(v.union([v.literal(""), schema]));
-		const empty = v.pipe(v.literal(""), v.transform(() => void 0));
-		return v.optional(v.union([empty, schema]));
-	}
-	return function build(json) {
+		const [first] = issues;
+		if (first) throw new TypeError(`${at}: ${formatPath(first.path)}: ${first.message}`);
+	}
+}
+function issue(code, path, message) {
+	return {
+		code,
+		path,
+		message
+	};
+}
+function toIssues(code, path, valibotIssues) {
+	return valibotIssues.map((valibotIssue) => {
+		const keys = valibotIssue.path?.map((item) => item.key) ?? [];
+		return issue(code, [...path, ...keys], valibotIssue.message);
+	});
+}
+// src/builder/create-schema-builder.ts
+function createSchemaBuilder(options = {}) {
+	const registry = mergeRegistry(options);
+	checkRegistry(registry);
+	const messages = {
+		required: options.messages?.required ?? "Required",
+		resolve: (text, ctx) => options.resolveMessage?.(text, ctx) ?? text
+	};
+	/** Every issue in the definition, in document order. Never throws on bad input. */
+	function validate(json) {
+		const { issues } = checkDefinition(json, registry);
+		return issues.length ? {
+			success: false,
+			issues
+		} : {
+			success: true,
+			issues: []
+		};
+	}
+	function build(json) {
+		const { issues, fields } = checkDefinition(json, registry);
+		if (issues.length) throw new DefinitionError(issues);
 		const entries = {};
-		json.fields.forEach((field, i) => {
-			if (field.name in entries) throw new Error(`fields[${i}]: duplicate name "${field.name}"`);
-			entries[field.name] = buildField(field, i);
-		});
+		for (const field of fields) entries[field.name] = buildFieldSchema(field, messages);
 		return v.object(entries);
+	}
+	/**
+	* The registered rules that can be used on a field of `kind`, e.g. for a rule picker.
+	*/
+	function rulesForKind(kind) {
+		return Object.entries(registry.rules).filter(([, def]) => def.kinds.includes(kind));
+	}
+	return {
+		build,
+		validate,
+		rulesForKind,
+		kinds: registry.kinds,
+		fieldTypes: registry.fieldTypes,
+		rules: registry.rules
 	};
 }
-export { createSchemaBuilder, defaultFieldTypes, defaultRules, defineRule };
+// src/field-types/define-field-type.ts
+const defineFieldType = (def) => def;
+export { DefinitionError, RESERVED_FIELD_KEYS, RESERVED_RULE_KEYS, comparisonRules, contentRules, createSchemaBuilder, dateRules, defaultFieldTypes, defaultKinds, defaultRules, defineFieldType, defineRule, fileRules, formatPath, formatRules, lengthRules, normalizeRules, numberRules, textUnitRules };
 
 //# sourceMappingURL=index.js.map