@whatsaaaa/form-builder-schema 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,8 +1,28 @@
 import * as v from "valibot";
+// src/shared/each-item.ts
+/**
+* Checks every item of an array with `schema` and reports the issues on the array itself.
+* Formisch keeps no field for each item of an array value, so an issue with an item's index in
+* its path would show nowhere.
+*/
+function eachItem(schema) {
+	return v.rawCheck(({ dataset, config, addIssue }) => {
+		if (!dataset.typed || !Array.isArray(dataset.value)) return;
+		for (const item of dataset.value) {
+			const result = v.safeParse(schema, item, config);
+			for (const issue of result.issues ?? []) addIssue({
+				message: issue.message,
+				input: item,
+				expected: issue.expected ?? void 0,
+				received: issue.received
+			});
+		}
+	});
+}
 // 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.
+* then the type's default rules and the field's rules, and last the type's `finalize()`.
 */
 function buildFieldSchema(checked, messages) {
 	const { field, path, type, kind } = checked;
@@ -11,8 +31,14 @@ function buildFieldSchema(checked, messages) {
 		field,
 		path
 	});
-	const normalize = [];
-	const validate = [];
+	const whole = {
+		normalize: [],
+		validate: []
+	};
+	const each = {
+		normalize: [],
+		validate: []
+	};
 	for (const rule of checked.rules) {
 		const message = rule.message === void 0 ? void 0 : messages.resolve(rule.message, {
 			field,
@@ -20,25 +46,31 @@ function buildFieldSchema(checked, messages) {
 			path
 		});
 		const action = rule.def.create(rule.params, message);
-		if (rule.def.stage === "normalize") normalize.push(action);
-		else validate.push(action);
+		const stage = rule.def.stage ?? "validate";
+		if (rule.each) each[stage].push(action);
+		else whole[stage].push(action);
 	}
+	if (each.normalize.length) whole.normalize.unshift(v.array(pipe(v.unknown(), each.normalize)));
+	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 requiredCheck = required ? kind.required?.(requiredMessage) : void 0;
-	const head = pipe(base, requiredCheck ? [...normalize, requiredCheck] : normalize);
+	const requiredCheck = !required ? void 0 : type.required ? type.required(requiredMessage) : kind.required?.(requiredMessage);
+	const head = pipe(base, requiredCheck ? [...whole.normalize, requiredCheck] : whole.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))));
+	const schema = whenFilled(v.pipe(head, whenFilled(pipe(v.unknown(), whole.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 = {
+const pipe = (schema, items) => items.reduce((acc, item) => v.pipe(acc, item), schema);
+// src/field-types/basic-types.ts
+/** Types with one plain value and no props. Each maps to a native input. */
+const basicTypes = {
 	text: {
 		kind: "string",
 		schema: () => v.string()
 	},
-	password: {
+	textarea: {
 		kind: "string",
 		schema: () => v.string()
 	},
@@ -47,10 +79,149 @@ const defaultFieldTypes = {
 		schema: () => v.string(),
 		defaultRules: [{ rule: "email" }]
 	},
+	password: {
+		kind: "string",
+		schema: () => v.string()
+	},
+	url: {
+		kind: "string",
+		schema: () => v.string(),
+		defaultRules: [{ rule: "url" }]
+	},
+	tel: {
+		kind: "string",
+		schema: () => v.string()
+	},
 	number: {
 		kind: "number",
 		schema: () => v.number()
+	},
+	checkbox: {
+		kind: "boolean",
+		schema: () => v.boolean()
+	}
+};
+// src/field-types/define-field-type.ts
+const defineFieldType = (def) => def;
+// src/field-types/choice-types.ts
+const options = (value) => v.pipe(v.array(v.object({
+	value,
+	label: v.string()
+})), v.minLength(1, "Give at least one option"), v.check((items) => new Set(items.map((item) => typeof item.value)).size <= 1, "Give every option a value of the same type"), v.check((items) => new Set(items.map((item) => item.value)).size === items.length, "Give every option a different value"));
+const stringOrNumber = v.union([v.string(), v.number()]);
+const anyValue = v.union([
+	v.string(),
+	v.number(),
+	v.boolean()
+]);
+/** The options' value type. Every option has the same one. */
+const kindOf = (items) => {
+	const [first] = items;
+	return first ? typeof first.value : "string";
+};
+/** One of the option values. `v.picklist` can't hold booleans, so this is a union of literals. */
+const oneOf = (items) => v.union(items.map((item) => v.literal(item.value)));
+const choiceTypes = {
+	select: defineFieldType({
+		kind: (field) => field.options ? kindOf(field.options) : field.valueType ?? "string",
+		props: v.object({
+			options: v.optional(options(stringOrNumber)),
+			/** The value's type while `options` is missing, e.g. until they load from an API. */
+			valueType: v.optional(v.picklist(["string", "number"]))
+		}),
+		schema: (field) => {
+			if (field.options) return oneOf(field.options);
+			return field.valueType === "number" ? v.number() : v.string();
+		}
+	}),
+	radio: defineFieldType({
+		kind: (field) => kindOf(field.options),
+		props: v.object({ options: options(anyValue) }),
+		schema: (field) => oneOf(field.options),
+		required: () => null
+	}),
+	multiselect: defineFieldType({
+		kind: "array",
+		itemKind: (field) => kindOf(field.options),
+		props: v.object({ options: options(stringOrNumber) }),
+		schema: (field) => v.array(oneOf(field.options))
+	})
+};
+// src/field-types/date-types.ts
+const outputProps = v.object({ 
+/** `'date'` turns the ISO string into a `Date`. Defaults to `'string'`. */
+output: v.optional(v.picklist(["string", "date"])) });
+const finalize = (field) => field.output === "date" ? v.toDate() : void 0;
+/**
+* Dates and times are ISO strings, the values of <input type="date|time|datetime-local">.
+* The format is part of the type rather than a default rule, so these types don't depend on
+* `dateRules` being registered.
+*/
+const dateTypes = {
+	date: defineFieldType({
+		kind: "date",
+		props: outputProps,
+		schema: () => v.pipe(v.string(), v.isoDate()),
+		finalize
+	}),
+	time: {
+		kind: "date",
+		schema: () => v.pipe(v.string(), v.isoTime())
+	},
+	datetime: defineFieldType({
+		kind: "date",
+		props: outputProps,
+		schema: () => v.pipe(v.string(), v.isoDateTime()),
+		finalize
+	})
+};
+// src/field-types/display-types.ts
+/**
+* Elements without a value. They need no name and add no output key. Their `text` can be an
+* i18n key: renderers resolve it with the same function they pass as `resolveMessage`.
+*/
+const displayTypes = {
+	heading: defineFieldType({
+		kind: "none",
+		props: v.object({
+			text: v.string(),
+			/** 1 to 6. Defaults to 2. */
+			level: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(6)))
+		})
+	}),
+	paragraph: defineFieldType({
+		kind: "none",
+		props: v.object({ text: v.string() })
+	}),
+	divider: { kind: "none" }
+};
+// src/field-types/file-type.ts
+const mimeTypes = (accept) => accept.split(",").map((type) => type.trim());
+/**
+* A File, or an array of them with `multiple`. Rules for files, like `maxSize`, run on each one;
+* rules for arrays, like `maxLength`, limit the count.
+*/
+const fileType = defineFieldType({
+	kind: (field) => field.multiple ? "array" : "file",
+	itemKind: "file",
+	props: v.object({
+		multiple: v.optional(v.boolean()),
+		accept: v.optional(v.pipe(v.string(), v.check((input) => mimeTypes(input).every((type) => /^[\w.+-]+\/[\w.+-]+$/.test(type)), "Use MIME types separated by commas, such as image/png,image/jpeg")))
+	}),
+	schema: (field) => {
+		const file = field.accept ? v.pipe(v.file(), v.mimeType(mimeTypes(field.accept))) : v.file();
+		if (!field.multiple) return file;
+		return field.accept ? v.pipe(v.array(v.file()), eachItem(file)) : v.array(file);
 	}
+});
+// src/field-types/default-field-types.ts
+/** Every built-in field type. */
+const defaultFieldTypes = {
+	...basicTypes,
+	...dateTypes,
+	...choiceTypes,
+	file: fileType,
+	...displayTypes
 };
 // src/kinds/default-kinds.ts
 const isNil = (input) => input === void 0 || input === null;
@@ -78,58 +249,514 @@ const defaultKinds = {
 };
 // src/rules/define-rule.ts
 const defineRule = (def) => def;
-// src/rules/default-rules.ts
-const nonNegInt = v.pipe(v.number(), v.integer(), v.minValue(0));
-const defaultRules = {
-	trim: 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"],
-		stage: "normalize",
-		create: () => v.trim()
+		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)
 	}),
-	minLength: defineRule({
+	startsWith: defineRule({
+		kinds: ["string"],
+		params: stringParams,
+		meta: meta$5("Starts with"),
+		create: (p, m) => v.startsWith(p.value, m)
+	}),
+	endsWith: defineRule({
 		kinds: ["string"],
-		params: v.object({ value: nonNegInt }),
+		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: 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"],
-		create: (_, m) => v.email(m)
+		stage,
+		meta: meta$2("Trim start"),
+		create: () => v.trimStart()
 	}),
-	url: defineRule({
+	trimEnd: defineRule({
 		kinds: ["string"],
-		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"],
+		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/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,
@@ -140,7 +767,7 @@ function mergeRegistry(custom) {
 			...custom.fieldTypes
 		}),
 		rules: Object.freeze({
-			...defaultRules,
+			...rules,
 			...custom.rules
 		})
 	};
@@ -165,6 +792,22 @@ var DefinitionError = class extends Error {
 		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.
@@ -266,26 +909,53 @@ function checkField(raw, path, registry, names, issues) {
 		}
 		return;
 	}
-	const fieldRules = (shape.output.rules ?? []).flatMap((rule, j) => checkRule(rule, type?.kind, [
+	const withProps = props && {
+		...field,
+		...props
+	};
+	const kind = resolveKind(type.kind, withProps);
+	if (kind === void 0) return void 0;
+	const kinds = {
+		kind,
+		itemKind: kind === "array" ? resolveKind(type.itemKind, withProps) : void 0
+	};
+	const fieldRules = (shape.output.rules ?? []).flatMap((rule, j) => checkRule(rule, kinds, [
 		...path,
 		"rules",
 		j
 	], registry, issues) ?? []);
-	if (issues.length > issueCount || !field.name) return void 0;
+	if (issues.length > issueCount || !field.name || !withProps) 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, []) ?? []);
+	const defaultRules = checkDefaultRules(field.type, type, kinds, registry).filter((rule) => !overridden.has(rule.name));
 	return {
 		name: field.name,
-		field: {
-			...field,
-			...props
-		},
+		field: withProps,
 		path,
 		type,
-		kind: registry.kinds[type?.kind],
+		kind: kindDef(field.type, kind, registry),
 		rules: [...defaultRules, ...fieldRules]
 	};
 }
+function resolveKind(kind, field) {
+	if (typeof kind !== "function") return kind;
+	return field && kind(field);
+}
+/** A kind that doesn't fit is a mistake in the field type, not in the definition. */
+function kindDef(typeName, kind, registry) {
+	const at = `Field type "${typeName}"`;
+	if (kind === "none") throw new TypeError(`${at}: kind() can't return 'none'`);
+	const def = lookup(registry.kinds, kind);
+	if (!def) throw new TypeError(`${at}: kind "${kind}" is not registered`);
+	return def;
+}
+/** Throws for a default rule that doesn't fit, because that is a mistake in the type. */
+function checkDefaultRules(typeName, type, kinds, registry) {
+	const issues = [];
+	const rules = (type.defaultRules ?? []).flatMap((rule, j) => checkRule(rule, kinds, ["defaultRules", j], registry, issues) ?? []);
+	const [first] = issues;
+	if (first) throw new TypeError(`Field type "${typeName}": ${formatPath(first.path)}: ${first.message}`);
+	return rules;
+}
 function checkProps(field, type, path, issues) {
 	const propKeys = Object.keys(type.props?.entries ?? {});
 	const input = {};
@@ -298,9 +968,8 @@ function checkProps(field, type, path, issues) {
 	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) {
+function checkRule(raw, { kind, itemKind }, path, registry, issues) {
 	const shape = v.safeParse(ruleShape, raw);
 	if (!shape.success) {
 		issues.push(...toIssues("invalid_shape", path, shape.issues));
@@ -312,41 +981,44 @@ function checkRule(raw, kind, path, registry, issues) {
 		issues.push(issue("unknown_rule", [...path, "rule"], `Unknown rule "${rule.rule}"`));
 		return;
 	}
-	const issueCount = issues.length;
-	if (!def.kinds.includes(kind)) {
-		const message = `Rule "${rule.rule} can't be used on ${kind} fields`;
+	const each = !def.kinds.includes(kind) && !!itemKind && def.kinds.includes(itemKind);
+	if (!def.kinds.includes(kind) && !each) {
+		const items = itemKind ? ` or their ${itemKind} items` : "";
+		const message = `Rule "${rule.rule}" can't be used on ${kind} fields${items}`;
 		issues.push(issue("kind_mismatch", [...path, "rule"], message));
+		return;
 	}
-	const paramKeys = Object.keys(def.params?.entries ?? {});
+	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}"`));
 	}
-	const parsed = v.safeParse(def.params ?? noParams, input);
+	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
+		message: rule.message,
+		each
 	};
 }
 function checkRegistry(registry) {
-	for (const [name, rule] of Object.entries(registry.rules)) for (const key of Object.keys(rule.params?.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.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`);
+		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.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 [first] = issues;
-		if (first) throw new TypeError(`${at}: ${formatPath(first.path)}: ${first.message}`);
+		if (typeof type.kind === "string" && typeof type.itemKind !== "function") checkDefaultRules(name, type, {
+			kind: type.kind,
+			itemKind: type.kind === "array" ? type.itemKind : void 0
+		}, registry);
 	}
 }
 function issue(code, path, message) {
@@ -388,16 +1060,21 @@ function createSchemaBuilder(options = {}) {
 		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
 	};
 }
-// src/field-types/define-field-type.ts
-const defineFieldType = (def) => def;
-export { DefinitionError, RESERVED_FIELD_KEYS, RESERVED_RULE_KEYS, createSchemaBuilder, defaultFieldTypes, defaultKinds, defaultRules, defineFieldType, defineRule, formatPath };
+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