@whatsaaaa/form-builder-schema 0.2.0 → 0.3.0

package/dist/index.js

@@ -78,58 +78,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: v.object({ value: nonNegInt }),
+		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: 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 +596,7 @@ function mergeRegistry(custom) {
 			...custom.fieldTypes
 		}),
 		rules: Object.freeze({
-			...defaultRules,
+			...rules,
 			...custom.rules
 		})
 	};
@@ -165,6 +621,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.
@@ -312,19 +784,21 @@ 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 message = `Rule "${rule.rule}" can't be used on ${kind} fields`;
 		issues.push(issue("kind_mismatch", [...path, "rule"], message));
+		return;
 	}
-	const paramKeys = Object.keys(def.params?.entries ?? {});
+	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(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 {
@@ -335,7 +809,7 @@ function checkRule(raw, kind, path, registry, issues) {
 	};
 }
 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`);
@@ -388,9 +862,16 @@ 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
@@ -398,6 +879,6 @@ function createSchemaBuilder(options = {}) {
 }
 // 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