mlform 0.1.8 → 0.1.10

package/dist/builtins-D8rXH4ED.js

@@ -0,0 +1,725 @@
+import { i as e, s as t } from "./schema-DSAZ6bts.js";
+import { s as n } from "./primitives-k9HTnd72.js";
+import * as r from "zod";
+//#region src/builtins/constants.ts
+var i = {
+	classifier: "classifier",
+	regressor: "regressor"
+}, a = {
+	classifier: i.classifier,
+	regressor: i.regressor
+}, o = {
+	text: "text",
+	number: "number",
+	boolean: "boolean",
+	category: "category",
+	date: "date",
+	series: "series",
+	longText: "long-text",
+	singleChoice: "single-choice",
+	multiChoice: "multi-choice",
+	rating: "rating"
+}, s = {
+	classifier: "Classifier report",
+	regressor: "Regressor report"
+}, c = {
+	unknownPrediction: "Unknown",
+	classifierClassLabel: (e) => `Class ${e + 1}`
+}, l = {
+	invalidNumber: "Value must be a valid number.",
+	textPatternMismatch: "Value does not match the expected pattern.",
+	booleanRequired: "This field must be accepted.",
+	categoryOptionMismatch: "Value must match one of the available options.",
+	invalidTextLengthRange: "Minimum length cannot exceed maximum length.",
+	invalidNumericRange: "Minimum value cannot exceed maximum value.",
+	invalidDateRange: "Minimum date cannot be after maximum date.",
+	invalidPointCountRange: "Minimum number of points cannot exceed maximum number of points.",
+	minLength: (e) => `Minimum length is ${e} characters.`,
+	maxLength: (e) => `Maximum length is ${e} characters.`,
+	minValue: (e) => `Minimum value is ${e}.`,
+	maxValue: (e) => `Maximum value is ${e}.`,
+	stepValue: (e) => `Value must be a multiple of ${e}.`,
+	dateOnOrAfter: (e) => `Date must be on or after ${e}.`,
+	dateOnOrBefore: (e) => `Date must be on or before ${e}.`,
+	stepDate: (e) => `Date must fall on a step of ${e} day(s) from the minimum date.`,
+	minPoints: (e) => `Minimum number of points is ${e}.`,
+	maxPoints: (e) => `Maximum number of points is ${e}.`,
+	timestampsUnique: "Timestamps must be unique.",
+	timestampsAscending: "Timestamps must be sorted in ascending order.",
+	timestampsDescending: "Timestamps must be sorted in descending order."
+}, u = r.record(r.string(), r.unknown()).optional(), d = r.custom((e) => typeof e == "function"), f = r.enum([
+	"idle",
+	"editing",
+	"validating",
+	"submitting",
+	"success",
+	"error"
+]), p = r.lazy(() => r.union([
+	r.object({
+		kind: r.literal("field-value"),
+		field: r.string().min(1),
+		equals: r.unknown().optional(),
+		notEquals: r.unknown().optional(),
+		greaterThan: r.unknown().optional(),
+		greaterThanOrEqual: r.unknown().optional(),
+		lessThan: r.unknown().optional(),
+		lessThanOrEqual: r.unknown().optional(),
+		in: r.array(r.unknown()).optional(),
+		notIn: r.array(r.unknown()).optional(),
+		empty: r.boolean().optional(),
+		notEmpty: r.boolean().optional(),
+		truthy: r.boolean().optional(),
+		falsy: r.boolean().optional()
+	}),
+	r.object({
+		kind: r.literal("field-comparison"),
+		field: r.string().min(1),
+		otherField: r.string().min(1),
+		operator: r.enum([
+			"eq",
+			"neq",
+			"gt",
+			"gte",
+			"lt",
+			"lte"
+		])
+	}),
+	r.object({
+		kind: r.literal("form-status"),
+		equals: r.union([f, r.array(f).min(1)])
+	}),
+	r.object({
+		kind: r.literal("submit-count"),
+		eq: r.number().int().nonnegative().optional(),
+		gte: r.number().int().nonnegative().optional(),
+		lte: r.number().int().nonnegative().optional()
+	}),
+	r.object({
+		kind: r.literal("all"),
+		conditions: r.array(p).min(1)
+	}),
+	r.object({
+		kind: r.literal("any"),
+		conditions: r.array(p).min(1)
+	}),
+	r.object({
+		kind: r.literal("not"),
+		condition: p
+	})
+])), m = r.union([d, p]), h = {
+	id: r.string().optional(),
+	label: r.string().min(1),
+	description: r.string().optional(),
+	showDescriptionInline: r.boolean().optional().default(!1),
+	required: r.boolean().optional().default(!1),
+	disabled: r.boolean().optional().default(!1),
+	hidden: r.boolean().optional().default(!1),
+	readOnly: r.boolean().optional().default(!1),
+	disabledWhen: m.optional(),
+	hiddenWhen: m.optional(),
+	readOnlyWhen: m.optional(),
+	asyncValidationDebounceMs: r.number().int().nonnegative().optional(),
+	inactiveFieldPolicy: r.enum([
+		"include",
+		"omit",
+		"reset-on-hide"
+	]).optional(),
+	includeInSubmission: r.boolean().optional(),
+	valuePath: r.union([r.string().min(1), r.array(r.string().min(1)).min(1)]).optional(),
+	defaultValue: r.unknown().optional(),
+	ui: u
+}, g = {
+	id: r.string().optional(),
+	label: r.string().optional(),
+	description: r.string().optional(),
+	source: r.string().optional(),
+	ui: u
+}, _ = r.union([r.string(), r.object({
+	label: r.string(),
+	value: r.string()
+})]), v = (e, t) => {
+	let n = e.raw;
+	if (!(typeof n != "object" || !n || !("outputs" in n) || !Array.isArray(n.outputs))) return n.outputs.find((e) => e.type === t);
+}, y = (e, t, n) => ({
+	component: e,
+	props: {
+		id: t.id,
+		kind: t.kind,
+		label: t.label,
+		description: t.description ?? "",
+		showDescriptionInline: !!t.showDescriptionInline,
+		required: !!t.required,
+		disabled: !!t.disabled,
+		...n,
+		...t.ui
+	}
+}), b = {
+	kind: "boolean",
+	schema: r.object({
+		kind: r.literal("boolean"),
+		...h,
+		trueLabel: r.string().optional(),
+		falseLabel: r.string().optional()
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "boolean" ? e.defaultValue : !1;
+	},
+	normalizeValue(e) {
+		return !!e;
+	},
+	validate(e, t) {
+		return t.required && e !== !0 ? [l.booleanRequired] : [];
+	},
+	describe(e, t) {
+		return y("boolean-field", e, {
+			checked: t.state.value,
+			trueLabel: e.trueLabel,
+			falseLabel: e.falseLabel,
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, x = {
+	kind: "category",
+	schema: r.object({
+		kind: r.literal("category"),
+		...h,
+		options: r.array(_).min(1)
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "string" ? e.defaultValue : null;
+	},
+	normalizeValue(e) {
+		return e == null || e === "" ? null : typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "bigint" ? `${e}` : null;
+	},
+	validate(e, t) {
+		return e === null || t.options.map((e) => typeof e == "string" ? e : e.value).includes(e) ? [] : [l.categoryOptionMismatch];
+	},
+	describe(e, t) {
+		return y("category-field", e, {
+			value: t.state.value,
+			options: e.options,
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, S = r.object({
+	label: r.string(),
+	value: r.string(),
+	mapping: r.record(r.string(), r.unknown())
+}), C = {
+	kind: "mapped-category",
+	schema: r.object({
+		kind: r.literal("mapped-category"),
+		...h,
+		includeInSubmission: r.boolean().optional().default(!1),
+		options: r.array(S).min(1)
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "string" ? e.defaultValue : null;
+	},
+	normalizeValue(e) {
+		return e == null || e === "" ? null : typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "bigint" ? `${e}` : null;
+	},
+	validate(e, t) {
+		return e === null || t.options.map((e) => e.value).includes(e) ? [] : [l.categoryOptionMismatch];
+	},
+	describe(e, t) {
+		return y("category-field", e, {
+			value: t.state.value,
+			options: e.options.map((e) => ({
+				label: e.label,
+				value: e.value
+			})),
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, w = (e) => typeof e == "object" && !!e && !Array.isArray(e), T = (e) => {
+	if (e instanceof Date) return Number.isNaN(e.getTime()) ? null : e;
+	if (typeof e == "string" || typeof e == "number") {
+		let t = new Date(e);
+		return Number.isNaN(t.getTime()) ? null : t;
+	}
+	return null;
+}, E = {
+	kind: "date",
+	schema: r.object({
+		kind: r.literal("date"),
+		...h,
+		min: r.string().optional(),
+		max: r.string().optional(),
+		step: r.number().positive().optional()
+	}),
+	getDefaultValue(e) {
+		return T(e.defaultValue) ?? null;
+	},
+	normalizeValue(e) {
+		return T(e);
+	},
+	serializeValue(e) {
+		return e instanceof Date ? e.toISOString() : e;
+	},
+	validate(e, t) {
+		let n = [], r = T(t.min), i = T(t.max);
+		if (r && i && r.getTime() > i.getTime() && n.push(l.invalidDateRange), e === null) return n;
+		if (r && e.getTime() < r.getTime() && n.push(l.dateOnOrAfter(String(t.min))), i && e.getTime() > i.getTime() && n.push(l.dateOnOrBefore(String(t.max))), t.step !== void 0) {
+			let i = r ?? /* @__PURE__ */ new Date("1970-01-01T00:00:00Z");
+			Math.round(Math.abs(e.getTime() - i.getTime()) / 864e5) % t.step !== 0 && n.push(l.stepDate(t.step));
+		}
+		return n;
+	},
+	describe(e, t) {
+		return y("date-field", e, {
+			value: t.state.value instanceof Date ? t.state.value.toISOString().slice(0, 10) : t.state.value,
+			min: e.min,
+			max: e.max,
+			step: e.step,
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, D = {
+	kind: "long-text",
+	schema: r.object({
+		kind: r.literal("long-text"),
+		...h,
+		placeholder: r.string().optional(),
+		minLength: r.number().int().nonnegative().optional(),
+		maxLength: r.number().int().nonnegative().optional(),
+		rows: r.number().int().positive().optional()
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "string" ? e.defaultValue : "";
+	},
+	normalizeValue(e) {
+		return typeof e == "string" ? e : typeof e == "number" || typeof e == "boolean" || typeof e == "bigint" ? `${e}` : "";
+	},
+	validate(e, t) {
+		let n = [];
+		return t.minLength !== void 0 && t.maxLength !== void 0 && t.minLength > t.maxLength && n.push(l.invalidTextLengthRange), e.length === 0 ? n : (t.minLength !== void 0 && e.length < t.minLength && n.push(l.minLength(t.minLength)), t.maxLength !== void 0 && e.length > t.maxLength && n.push(l.maxLength(t.maxLength)), n);
+	},
+	describe(e, t) {
+		return y("long-text-field", e, {
+			value: t.state.value,
+			placeholder: e.placeholder ?? "",
+			minLength: e.minLength,
+			maxLength: e.maxLength,
+			rows: e.rows,
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, O = {
+	kind: "multi-choice",
+	schema: r.object({
+		kind: r.literal("multi-choice"),
+		...h,
+		options: r.array(_).min(1),
+		layout: r.enum(["horizontal", "vertical"]).optional()
+	}),
+	getDefaultValue(e) {
+		return Array.isArray(e.defaultValue) ? e.defaultValue.filter((e) => typeof e == "string").map(String) : [];
+	},
+	normalizeValue(e) {
+		return Array.isArray(e) ? e.filter((e) => typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "bigint").map(String) : [];
+	},
+	cloneValue(e) {
+		return [...e];
+	},
+	isEqual(e, t) {
+		return e.length === t.length ? e.every((e, n) => e === t[n]) : !1;
+	},
+	validate(e, t) {
+		if (e.length === 0) return [];
+		let n = t.options.map((e) => typeof e == "string" ? e : e.value);
+		return e.filter((e) => !n.includes(e)).length > 0 ? [l.categoryOptionMismatch] : [];
+	},
+	describe(e, t) {
+		return y("multi-choice-field", e, {
+			value: t.state.value,
+			options: e.options,
+			layout: e.layout ?? "vertical",
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, k = {
+	kind: "number",
+	schema: r.object({
+		kind: r.literal("number"),
+		...h,
+		min: r.number().optional(),
+		max: r.number().optional(),
+		step: r.number().positive().optional(),
+		unit: r.string().optional(),
+		placeholder: r.string().optional()
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "number" ? e.defaultValue : null;
+	},
+	normalizeValue(e) {
+		if (e == null || e === "") return null;
+		if (typeof e == "number") return Number.isNaN(e) ? null : e;
+		if (typeof e == "string") {
+			let t = e.trim();
+			if (t.length === 0) return null;
+			let n = Number(t);
+			return Number.isNaN(n) ? e : n;
+		}
+		let t = Number(e);
+		return Number.isNaN(t) ? null : t;
+	},
+	validate(e, t) {
+		let n = [];
+		if (t.min !== void 0 && t.max !== void 0 && t.min > t.max && n.push(l.invalidNumericRange), e === null) return n;
+		if (typeof e != "number") return n.push(l.invalidNumber), n;
+		if (t.min !== void 0 && e < t.min && n.push(l.minValue(t.min)), t.max !== void 0 && e > t.max && n.push(l.maxValue(t.max)), t.step !== void 0) {
+			let r = t.min ?? 0, i = Math.abs(e - r) % t.step, a = t.step * 1e-9;
+			i > a && Math.abs(i - t.step) > a && n.push(l.stepValue(t.step));
+		}
+		return n;
+	},
+	describe(e, t) {
+		let n = e.min !== void 0 && e.max !== void 0 && !e.required && t.state.value !== null;
+		return y("number-field", e, {
+			value: t.state.value,
+			min: e.min,
+			max: e.max,
+			step: e.step,
+			unit: e.unit,
+			placeholder: e.placeholder ?? "",
+			input: n ? "range" : "text",
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, A = {
+	kind: "rating",
+	schema: r.object({
+		kind: r.literal("rating"),
+		...h,
+		min: r.number().int().optional(),
+		max: r.number().int().min(1),
+		step: r.number().int().positive().optional()
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "number" ? e.defaultValue : null;
+	},
+	normalizeValue(e) {
+		if (e == null) return null;
+		let t = typeof e == "number" ? e : Number(e);
+		return Number.isNaN(t) ? null : t;
+	},
+	validate(e, t) {
+		if (e === null) return [];
+		let n = [], r = t.min ?? 1, i = t.max;
+		return r > i ? (n.push(l.invalidNumericRange), n) : (e < r && n.push(l.minValue(r)), e > i && n.push(l.maxValue(i)), n);
+	},
+	describe(e, t) {
+		return y("rating-field", e, {
+			value: t.state.value,
+			min: e.min ?? 1,
+			max: e.max,
+			step: e.step ?? 1,
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, j = {
+	kind: "text",
+	schema: r.object({
+		kind: r.literal("text"),
+		...h,
+		placeholder: r.string().optional(),
+		minLength: r.number().int().nonnegative().optional(),
+		maxLength: r.number().int().nonnegative().optional(),
+		pattern: r.string().optional()
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "string" ? e.defaultValue : "";
+	},
+	normalizeValue(e) {
+		return typeof e == "string" ? e : typeof e == "number" || typeof e == "boolean" || typeof e == "bigint" ? `${e}` : "";
+	},
+	validate(e, t) {
+		let n = [];
+		return t.minLength !== void 0 && t.maxLength !== void 0 && t.minLength > t.maxLength && n.push(l.invalidTextLengthRange), e.length === 0 ? n : (t.minLength !== void 0 && e.length < t.minLength && n.push(l.minLength(t.minLength)), t.maxLength !== void 0 && e.length > t.maxLength && n.push(l.maxLength(t.maxLength)), t.pattern && !new RegExp(t.pattern).test(e) && n.push(l.textPatternMismatch), n);
+	},
+	describe(e, t) {
+		return y("text-field", e, {
+			value: t.state.value,
+			placeholder: e.placeholder ?? "",
+			minLength: e.minLength,
+			maxLength: e.maxLength,
+			pattern: e.pattern,
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, M = r.object({
+	kind: r.string().min(1),
+	label: r.string().min(1),
+	required: r.boolean().optional()
+}).passthrough(), N = r.object({
+	kind: r.literal("series"),
+	...h,
+	field1: M,
+	field2: M,
+	minPoints: r.number().int().nonnegative().optional(),
+	maxPoints: r.number().int().nonnegative().optional()
+}), ee = "This field is required.", P = (e) => e.toISOString().slice(0, 10), F = {
+	text: j,
+	number: k,
+	date: E,
+	category: x
+}, I = (e) => F[e], L = (e) => {
+	if (e == null || e === "") return null;
+	if (typeof e == "boolean") return e;
+	if (typeof e == "string") {
+		if (e === "true") return !0;
+		if (e === "false") return !1;
+	}
+	return !!e;
+}, R = (e, t) => {
+	if (e.kind === b.kind) return L(t);
+	let n = I(e.kind);
+	return n?.normalizeValue ? n.normalizeValue(t, e) : t;
+}, z = (e, t) => {
+	if (t == null) return null;
+	if (e.kind === "date" && t instanceof Date) return P(t);
+	let n = I(e.kind);
+	return n?.serializeValue ? n.serializeValue(t, e) : t;
+}, B = (e, t) => t == null ? !0 : typeof t == "string" ? t.trim().length === 0 : e.kind === b.kind ? t == null : !1, V = (e, t) => {
+	if (e.required && B(e, t)) return [ee];
+	if (e.kind === b.kind) {
+		if (t === null) return [];
+		let n = b.validate?.(t, e, {
+			field: {
+				...e,
+				id: e.label
+			},
+			values: {},
+			submitCount: 0,
+			validationVersion: 0,
+			signal: void 0
+		});
+		return Array.isArray(n) ? n : [];
+	}
+	let n = I(e.kind);
+	if (!n?.validate) return [];
+	let r = n.validate(t, e, {
+		field: {
+			...e,
+			id: e.label
+		},
+		values: {},
+		submitCount: 0,
+		validationVersion: 0,
+		signal: void 0
+	});
+	return Array.isArray(r) ? r : [];
+}, H = (e, t, n) => n.map((n) => `Row ${e + 1} (${t}): ${n}`), U = (e) => {
+	if (Array.isArray(e)) return e.length >= 2 ? {
+		field1: e[0],
+		field2: e[1]
+	} : null;
+	if (!w(e)) return null;
+	if ("field1" in e || "field2" in e) return {
+		field1: e.field1,
+		field2: e.field2
+	};
+	let t = Object.entries(e);
+	return t.length < 2 ? null : {
+		field1: t[0]?.[1],
+		field2: t[1]?.[1]
+	};
+}, W = (e, t) => {
+	let n = U(e);
+	return n ? {
+		field1: R(t.field1, n.field1),
+		field2: R(t.field2, n.field2)
+	} : null;
+}, G = (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	return t.minPoints !== void 0 && t.maxPoints !== void 0 && t.minPoints > t.maxPoints && n.add(l.invalidPointCountRange), t.minPoints !== void 0 && e.length < t.minPoints && n.add(l.minPoints(t.minPoints)), t.maxPoints !== void 0 && e.length > t.maxPoints && n.add(l.maxPoints(t.maxPoints)), n;
+}, K = {
+	kind: "series",
+	schema: N,
+	getDefaultValue(e) {
+		return Array.isArray(e.defaultValue) ? e.defaultValue.map((t) => W(t, e)).filter((e) => e !== null) : [];
+	},
+	normalizeValue(e, t) {
+		return Array.isArray(e) ? e.map((e) => W(e, t)).filter((e) => e !== null) : [];
+	},
+	serializeValue(e, t) {
+		return e.map((e) => ({
+			field1: z(t.field1, e.field1),
+			field2: z(t.field2, e.field2)
+		}));
+	},
+	validate(e, t) {
+		let n = G(e, t);
+		return e.forEach((e, r) => {
+			for (let i of H(r, t.field1.label, V(t.field1, e.field1))) n.add(i);
+			for (let i of H(r, t.field2.label, V(t.field2, e.field2))) n.add(i);
+		}), [...n];
+	},
+	describe(e, t) {
+		return y("series-field", e, {
+			value: Array.isArray(t.state.value) ? t.state.value.map((t) => w(t) ? {
+				field1: z(e.field1, t.field1),
+				field2: z(e.field2, t.field2)
+			} : t) : [],
+			field1: e.field1,
+			field2: e.field2,
+			minPoints: e.minPoints,
+			maxPoints: e.maxPoints,
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, q = {
+	kind: "single-choice",
+	schema: r.object({
+		kind: r.literal("single-choice"),
+		...h,
+		options: r.array(_).min(1),
+		layout: r.enum(["horizontal", "vertical"]).optional()
+	}),
+	getDefaultValue(e) {
+		return typeof e.defaultValue == "string" ? e.defaultValue : null;
+	},
+	normalizeValue(e) {
+		return e == null || e === "" ? null : typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "bigint" ? `${e}` : null;
+	},
+	validate(e, t) {
+		return e === null || t.options.map((e) => typeof e == "string" ? e : e.value).includes(e) ? [] : [l.categoryOptionMismatch];
+	},
+	describe(e, t) {
+		return y("single-choice-field", e, {
+			value: t.state.value,
+			options: e.options,
+			layout: e.layout ?? "vertical",
+			state: t.state.status,
+			errors: t.state.errors
+		});
+	}
+}, J = {
+	kind: "classifier",
+	partialUpdatePolicy: "validate",
+	schema: r.object({
+		kind: r.literal("classifier"),
+		...g,
+		labels: r.array(r.string()).optional(),
+		showClassProbabilities: r.boolean().optional().default(!0)
+	}),
+	resolvePayload(e, t) {
+		return t.result.reports[t.report.source] ?? v(t.result, a.classifier);
+	},
+	describe(e, t) {
+		return t.state.status === "idle" && t.payload === void 0 ? null : {
+			component: "classifier-report",
+			props: {
+				id: t.reportId,
+				kind: e.kind,
+				label: e.label ?? s.classifier,
+				description: e.description ?? "",
+				payload: t.payload,
+				error: t.state.error,
+				state: t.state.status,
+				showClassProbabilities: e.showClassProbabilities,
+				labels: e.labels,
+				...e.ui
+			}
+		};
+	}
+}, Y = {
+	kind: "regressor",
+	partialUpdatePolicy: "validate",
+	schema: r.object({
+		kind: r.literal("regressor"),
+		...g,
+		unit: r.string().optional(),
+		precision: r.number().int().nonnegative().optional().default(2)
+	}),
+	resolvePayload(e, t) {
+		return t.result.reports[t.report.source] ?? v(t.result, a.regressor);
+	},
+	describe(e, t) {
+		return t.state.status === "idle" && t.payload === void 0 ? null : {
+			component: "regressor-report",
+			props: {
+				id: t.reportId,
+				kind: e.kind,
+				label: e.label ?? s.regressor,
+				description: e.description ?? "",
+				payload: t.payload,
+				error: t.state.error,
+				state: t.state.status,
+				unit: e.unit,
+				precision: e.precision,
+				...e.ui
+			}
+		};
+	}
+}, X = (e) => e.kind === "mapped-category" ? e.config : null, Z = (e, n) => e.getField(n) ?? e.getField(t(n)), Q = async (e, t) => {
+	let n = t.getField(e.fieldId);
+	if (!n) return;
+	let r = X(n);
+	if (!r) return;
+	let i = e.values[e.fieldId], a = r.options.find((e) => e.value === i);
+	if (a?.mapping) {
+		for (let [n, r] of Object.entries(a.mapping)) {
+			let i = Z(t, n);
+			if (!i) throw Error(`mapped-category "${e.fieldId}": target field "${n}" not found in schema.`);
+			t.commitDerivedValue(i.id, r);
+		}
+		t.syncDerivedState();
+	}
+}, $ = () => ({
+	validate(e) {
+		for (let t of e.fields) {
+			let n = X(t);
+			if (n) {
+				for (let r of n.options) for (let n of Object.keys(r.mapping ?? {})) if (!Z(e, n)) throw Error(`mapped-category "${t.id}": mapping references unknown field "${n}".`);
+			}
+		}
+	},
+	async onValuesChanged(e, t) {
+		await Q(e, t);
+	}
+}), te = [
+	j,
+	k,
+	b,
+	x,
+	C,
+	E,
+	K,
+	D,
+	q,
+	O,
+	A
+], ne = [J, Y], re = (e, t) => {
+	!t.describe || e.getField(t.kind) || e.registerField({
+		kind: t.kind,
+		describe: t.describe
+	});
+}, ie = (e, t) => {
+	!t.describe || e.getReport(t.kind) || e.registerReport({
+		kind: t.kind,
+		describe: t.describe
+	});
+}, ae = () => e().registerReport(J).registerReport(Y), oe = () => {
+	let t = e(), r = n();
+	for (let e of te) t.registerField(e), re(r, e);
+	for (let e of ne) t.registerReport(e), ie(r, e);
+	return {
+		registry: t,
+		descriptorRegistry: r,
+		behaviors: [$()]
+	};
+};
+//#endregion
+export { l as S, o as _, J as a, i as b, j as c, O as d, D as f, b as g, x as h, Y as i, A as l, C as m, oe as n, q as o, E as p, $ as r, K as s, ae as t, k as u, a as v, s as x, c as y };