@voltro/client 0.54.0 → 0.56.0

package/dist/form.d.ts

@@ -174,6 +174,33 @@ export declare const formSections: (fields: ReadonlyArray<FieldDescriptor>) => R
  */
 export declare const resolveValidationMessage: (issue: Pick<FieldIssue, "id" | "params" | "fallback">, options?: ValidateOptions) => string;
 
+/**
+ * Keep only the keys the input schema DECLARES.
+ *
+ * The two submit paths had drifted apart on this, and the server sided with
+ * neither: `formDataToInput` (the no-JS path) documents "unknown keys are
+ * dropped", while the JS path validated with a decode that IGNORES excess
+ * properties and then sent the object UNCHANGED. Since 0.37 the server
+ * refuses an undeclared input field — so a form carrying anything beyond the
+ * mutation's input (a display toggle, a repeat control, a file held before
+ * upload, which is nearly every real form) passed client validation and was
+ * rejected on the wire, with a message pointing at no field. Measured by a
+ * deployment with `renderFormBinding`, our own harness.
+ *
+ * `toInput` is the seam for this and stays the recommended one — but it only
+ * protects a form that HAS one, and the failure mode of not having one was a
+ * green tick followed by a server refusal. Dropping matches the no-JS path,
+ * so the two submits now agree; a genuinely mistyped key still surfaces,
+ * because the field it was meant to be is then missing and fails validation.
+ *
+ * Non-struct schemas (a scalar input) are returned untouched — there is no
+ * declared key set to restrict against.
+ */
+export declare const restrictToSchema: (schema: Schema.Schema.Any, input: unknown) => {
+    readonly input: unknown;
+    readonly dropped: ReadonlyArray<string>;
+};
+
 /**
  * Derive table COLUMNS from a query's output `Schema` — an
  * `Schema.Array(Schema.Struct({...}))`. Drills into the array's element and maps
@@ -223,6 +250,6 @@ export declare interface ValidationResult {
 /** The default widget kinds the framework can render from a schema. `'custom'`
  *  means "no default widget" — the field needs a render-prop (a nested object,
  *  an array of objects, or a multi-branch union). Mirrors innovation/01's set. */
-export declare type WidgetKind = 'text' | 'textarea' | 'number' | 'checkbox' | 'switch' | 'select' | 'radio' | 'async-select' | 'multi-select' | 'date' | 'datetime' | 'daterange' | 'file' | 'hidden' | 'array' | 'reference' | 'custom';
+export declare type WidgetKind = 'text' | 'textarea' | 'rich-text' | 'number' | 'checkbox' | 'switch' | 'select' | 'radio' | 'async-select' | 'multi-select' | 'date' | 'datetime' | 'daterange' | 'file' | 'hidden' | 'array' | 'reference' | 'custom';
 
 export { }

package/dist/form.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as f, u as p } from "./formData-BO7zkG_F.js";
-export { f as FORM_FLASH_SCRIPT_ID, s as FORM_KEY_FIELD, u as FORM_PATH_PREFIX, i as FORM_REDIRECT_FIELD, d as decodeFieldIssues, t as documentLocale, e as formActionPath, c as formDataToInput, n as formField, r as formSections, a as resolveValidationMessage, l as schemaToColumns, o as schemaToFields, p as validateFields };
+import { C as e, S as t, _ as n, a as r, b as i, g as a, i as o, n as s, o as c, r as l, t as u, v as d, w as f, x as p, y as m } from "./formData-DtlF8t8h.js";
+export { u as FORM_FLASH_SCRIPT_ID, s as FORM_KEY_FIELD, l as FORM_PATH_PREFIX, o as FORM_REDIRECT_FIELD, a as decodeFieldIssues, n as documentLocale, r as formActionPath, c as formDataToInput, p as formField, t as formSections, d as resolveValidationMessage, m as restrictToSchema, e as schemaToColumns, f as schemaToFields, i as validateFields };

package/dist/formData-DtlF8t8h.js

@@ -0,0 +1,641 @@
+import { JSONSchema as e, Schema as t } from "effect";
+import * as n from "effect/SchemaAST";
+//#region src/schemaFields.ts
+var r = (e) => ({ jsonSchema: { "x-voltro": e } }), i = "#/$defs/", a = (e) => e.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").trim().replace(/^./, (e) => e.toUpperCase()), o = (e, t) => {
+	let n = e;
+	for (let e = 0; e < 8; e += 1) {
+		let e = n.$ref;
+		if (typeof e != "string" || !e.startsWith(i)) return n;
+		let r = t[e.slice(8)];
+		if (!r || typeof r != "object") return n;
+		n = r;
+	}
+	return n;
+}, s = (e) => {
+	if (!e || typeof e != "object") return !1;
+	let t = e;
+	if (t.type === "null" || t.const === null) return !0;
+	let n = t.enum;
+	return Array.isArray(n) && n.length === 1 && n[0] === null;
+}, c = (e, t) => {
+	let n = e.type;
+	if (Array.isArray(n) && n.includes("null")) {
+		let t = n.filter((e) => e !== "null");
+		return {
+			node: {
+				...e,
+				type: t.length === 1 ? t[0] : t
+			},
+			nullable: !0
+		};
+	}
+	for (let n of ["anyOf", "oneOf"]) {
+		let r = e[n];
+		if (!Array.isArray(r)) continue;
+		let i = r.filter((e) => !s(e));
+		if (i.length !== r.length) return i.length === 1 ? {
+			node: o(i[0], t),
+			nullable: !0
+		} : {
+			node: {
+				...e,
+				[n]: i
+			},
+			nullable: !0
+		};
+	}
+	return {
+		node: e,
+		nullable: !1
+	};
+}, l = (e) => e.map((e) => ({
+	value: String(e),
+	label: a(String(e))
+})), u = (e) => {
+	let t = e.enum;
+	if (Array.isArray(t) && t.length > 0) return {
+		widget: "select",
+		options: l(t)
+	};
+	let n = e.type, r = Array.isArray(n) ? n.find((e) => e !== "null") : n, i = e.format;
+	switch (r) {
+		case "string": return i === "date" ? { widget: "date" } : i === "date-time" ? { widget: "datetime" } : { widget: "text" };
+		case "integer":
+		case "number": return { widget: "number" };
+		case "boolean": return { widget: "checkbox" };
+		case "array": return { widget: "multi-select" };
+		default: return { widget: "custom" };
+	}
+}, ee = (e) => {
+	let t = e.$ref;
+	if (typeof t != "string" || !t.startsWith(i)) return;
+	let n = t.slice(8);
+	if (/DateTime/i.test(n) || /Timestamp/i.test(n)) return "datetime";
+	if (/Date/.test(n)) return "date";
+}, d = (e) => typeof e["x-voltro"] == "object" && e["x-voltro"] !== null ? e["x-voltro"] : {}, f = 4, p = (e, t, n, r = "", i, s = 0) => Object.entries(e).flatMap(([e, l]) => {
+	let { node: m, nullable: h } = c(o(l, n), n), g = o(m, n), _ = d(g), v = r === "" ? e : `${r}.${e}`, y = g.properties;
+	if (g.type === "object" && y !== void 0 && s < f && _.widget === void 0) return p(y, new Set(Array.isArray(g.required) ? g.required : []), n, v, {
+		path: _.section ?? v,
+		label: _.label ?? a(e)
+	}, s + 1);
+	let b = ee(l), { widget: x, options: S } = u(g);
+	b !== void 0 && (x = b);
+	let C;
+	if (g.type === "array") {
+		let e = g.items;
+		if (typeof e == "object" && e && !Array.isArray(e)) {
+			let t = o(e, n), r = t.properties;
+			t.type === "object" && r !== void 0 && (x = "array", C = p(r, new Set(Array.isArray(t.required) ? t.required : []), n));
+		}
+	}
+	_.widget !== void 0 && (x = _.widget), _.reference !== void 0 && _.widget === void 0 && (x = "reference");
+	let w = typeof g.description == "string" ? g.description : void 0, T = _.section ?? i?.path;
+	return [{
+		name: v,
+		label: _.label ?? a(e),
+		widget: x,
+		required: t.has(e),
+		nullable: h,
+		...S ? { options: S } : {},
+		jsonSchema: g,
+		...T === void 0 ? {} : {
+			section: T,
+			sectionLabel: i?.label ?? a(T)
+		},
+		...w === void 0 ? {} : { description: w },
+		..._.order === void 0 ? {} : { order: _.order },
+		...C === void 0 ? {} : { item: C },
+		..._.reference === void 0 ? {} : { reference: _.reference }
+	}];
+}), m = (e) => e.map((e, t) => [e, t]).sort((e, t) => (e[0].order ?? e[1]) - (t[0].order ?? t[1]) || e[1] - t[1]).map(([e]) => e), h = (t) => {
+	try {
+		return e.make(t);
+	} catch {
+		return;
+	}
+}, g = (e) => {
+	let t = h(e);
+	if (t === void 0) return [];
+	let n = t.$defs ?? {}, r = o(t, n), i = r.properties;
+	return i ? m(p(i, new Set(Array.isArray(r.required) ? r.required : []), n)) : [];
+}, _ = (e) => {
+	let t = h(e);
+	if (t === void 0) return [];
+	let n = t.$defs ?? {}, r = o(t, n);
+	if (r.type !== "array") return [];
+	let i = r.items;
+	if (!i || typeof i != "object") return [];
+	let a = o(i, n), s = a.properties;
+	return s ? p(s, new Set(Array.isArray(a.required) ? a.required : []), n) : [];
+}, v = (e) => {
+	let t = [];
+	for (let n of e) {
+		let e = t[t.length - 1];
+		if (e !== void 0 && e.name === n.section) {
+			e.fields.push(n);
+			continue;
+		}
+		t.push({
+			name: n.section,
+			label: n.sectionLabel,
+			fields: [n]
+		});
+	}
+	return t;
+}, y = {
+	en: {
+		"validation.required": "Required",
+		"validation.invalid": "Invalid value",
+		"validation.minLength": "Must be at least {min} characters",
+		"validation.maxLength": "Must be at most {max} characters",
+		"validation.pattern": "Invalid format",
+		"validation.minValue": "Must be at least {min}",
+		"validation.maxValue": "Must be at most {max}",
+		"validation.minItems": "Add at least {min}",
+		"validation.maxItems": "No more than {max}",
+		"validation.integer": "Must be a whole number",
+		"validation.checking": "Still checking…",
+		"validation.invalidEmail": "Enter a valid email address",
+		"validation.invalidUrl": "Enter a valid URL",
+		"validation.invalidUuid": "Enter a valid identifier",
+		"validation.betweenLength": "Must be between {min} and {max} characters",
+		"validation.exactLength": "Must be exactly {amount} characters",
+		"validation.minDate": "Must not be earlier than {min}",
+		"validation.maxDate": "Must not be later than {max}",
+		"validation.invalidFileType": "This file type is not allowed",
+		"validation.fileTooLarge": "File is too large"
+	},
+	de: {
+		"validation.required": "Pflichtfeld",
+		"validation.invalid": "Ungültiger Wert",
+		"validation.minLength": "Mindestens {min} Zeichen",
+		"validation.maxLength": "Höchstens {max} Zeichen",
+		"validation.pattern": "Ungültiges Format",
+		"validation.minValue": "Mindestens {min}",
+		"validation.maxValue": "Höchstens {max}",
+		"validation.minItems": "Mindestens {min}",
+		"validation.maxItems": "Höchstens {max}",
+		"validation.integer": "Ganze Zahl erforderlich",
+		"validation.checking": "Prüfung läuft…",
+		"validation.invalidEmail": "Bitte eine gültige E-Mail-Adresse eingeben",
+		"validation.invalidUrl": "Bitte eine gültige URL eingeben",
+		"validation.invalidUuid": "Bitte eine gültige Kennung eingeben",
+		"validation.betweenLength": "Muss zwischen {min} und {max} Zeichen haben",
+		"validation.exactLength": "Muss genau {amount} Zeichen haben",
+		"validation.minDate": "Darf nicht früher sein als {min}",
+		"validation.maxDate": "Darf nicht später sein als {max}",
+		"validation.invalidFileType": "Dieser Dateityp ist nicht erlaubt",
+		"validation.fileTooLarge": "Die Datei ist zu groß"
+	}
+}, b = (e, t) => e.replace(/\{(\w+)\}/g, (e, n) => {
+	let r = t?.[n];
+	return r === void 0 ? e : String(r);
+}), x = () => {
+	let e = globalThis.document?.documentElement?.lang ?? "";
+	return e === "" ? "en" : e;
+}, S = (e, t) => {
+	let n = t?.messages?.(e.id, e.params, e.fallback);
+	if (n !== void 0) return n;
+	let r = y[(t?.locale ?? x()).toLowerCase().split("-")[0] ?? "en"]?.[e.id] ?? y.en?.[e.id];
+	return r === void 0 ? e.fallback : b(r, e.params);
+}, C = (e) => {
+	let t = /^([a-z][\w-]*(?:\.[\w-]+)+)\|(\{.*\})$/.exec(e);
+	if (t !== null && t[1] !== void 0 && t[2] !== void 0) try {
+		return {
+			id: t[1],
+			params: JSON.parse(t[2]),
+			fallback: e
+		};
+	} catch {}
+	return /^[a-z][\w-]*(?:\.[\w-]+)+$/.test(e) ? {
+		id: e,
+		fallback: e
+	} : {
+		id: "validation.custom",
+		fallback: e
+	};
+}, w = {
+	email: "validation.invalidEmail",
+	"idn-email": "validation.invalidEmail",
+	uri: "validation.invalidUrl",
+	url: "validation.invalidUrl",
+	uuid: "validation.invalidUuid"
+}, T = (e, t) => {
+	let r = e.ast;
+	for (let e of t.split(".")) {
+		if (r === void 0) return {};
+		if (/^\d+$/.test(e)) {
+			r = r.rest?.[0]?.type;
+			continue;
+		}
+		let t;
+		try {
+			t = n.getPropertySignatures(r);
+		} catch {
+			return {};
+		}
+		r = t.find((t) => String(t.name) === e)?.type;
+	}
+	let i = {}, a = r;
+	for (let e = 0; e < 12 && a !== void 0; e += 1) {
+		let e = a.annotations?.[n.JSONSchemaAnnotationId] ?? {};
+		i.min === void 0 && typeof e.minLength == "number" && (i.min = e.minLength), i.max === void 0 && typeof e.maxLength == "number" && (i.max = e.maxLength), a = a.from;
+	}
+	return i;
+}, E = (e) => {
+	let r = e[n.SchemaIdAnnotationId], i = e[n.JSONSchemaAnnotationId] ?? {};
+	switch (r) {
+		case t.MinLengthSchemaId: return {
+			id: "validation.minLength",
+			params: { min: i.minLength }
+		};
+		case t.MaxLengthSchemaId: return {
+			id: "validation.maxLength",
+			params: { max: i.maxLength }
+		};
+		case t.LengthSchemaId: return {
+			id: "validation.exactLength",
+			params: { amount: i.minLength }
+		};
+		case t.PatternSchemaId: {
+			let e = typeof i.format == "string" ? w[i.format] : void 0;
+			return e === void 0 ? {
+				id: "validation.pattern",
+				params: { pattern: i.pattern }
+			} : { id: e };
+		}
+		case t.GreaterThanOrEqualToSchemaId: return {
+			id: "validation.minValue",
+			params: { min: i.minimum }
+		};
+		case t.LessThanOrEqualToSchemaId: return {
+			id: "validation.maxValue",
+			params: { max: i.maximum }
+		};
+		case t.GreaterThanSchemaId: return {
+			id: "validation.minValue",
+			params: {
+				min: i.exclusiveMinimum,
+				exclusive: !0
+			}
+		};
+		case t.LessThanSchemaId: return {
+			id: "validation.maxValue",
+			params: {
+				max: i.exclusiveMaximum,
+				exclusive: !0
+			}
+		};
+		case t.IntSchemaId: return { id: "validation.integer" };
+		case t.MinItemsSchemaId: return {
+			id: "validation.minItems",
+			params: {
+				count: i.minItems,
+				min: i.minItems
+			}
+		};
+		case t.MaxItemsSchemaId: return {
+			id: "validation.maxItems",
+			params: {
+				count: i.maxItems,
+				max: i.maxItems
+			}
+		};
+		case t.BetweenSchemaId: return {
+			id: "validation.minValue",
+			params: {
+				min: i.minimum,
+				max: i.maximum
+			}
+		};
+		default: {
+			let e = String(r ?? "");
+			return /GreaterThanOrEqualToDate|GreaterThanDate/.test(e) ? { id: "validation.minDate" } : /LessThanOrEqualToDate|LessThanDate/.test(e) ? { id: "validation.maxDate" } : { id: "validation.invalid" };
+		}
+	}
+}, D = (e, t) => {
+	let r = e[n.MessageAnnotationId];
+	if (typeof r == "function") try {
+		let e = r(t);
+		if (typeof e == "string") return e;
+		if (typeof e == "object" && e && typeof e.message == "string") return e.message;
+	} catch {}
+}, O = (e) => Array.isArray(e) ? e.map((e) => String(e)) : [String(e)], k = (e) => {
+	let t = [], n = (e, n, r, i) => {
+		t.push({
+			path: e.join("."),
+			id: n,
+			...r === void 0 ? {} : { params: r },
+			fallback: i
+		});
+	}, r = (e, t) => {
+		let r = C(t);
+		n(e, r.id, r.params, r.fallback);
+	}, i = (e, t) => {
+		switch (e._tag) {
+			case "Composite": {
+				let n = e.issues;
+				if (n === void 0) return;
+				for (let e of Array.isArray(n) ? n : [n]) i(e, t);
+				return;
+			}
+			case "Pointer":
+				e.issue !== void 0 && i(e.issue, [...t, ...O(e.path)]);
+				return;
+			case "Refinement": {
+				if (e.kind === "From") {
+					e.issue !== void 0 && i(e.issue, t);
+					return;
+				}
+				let a = e.ast?.annotations ?? {}, o = D(a, e);
+				if (o !== void 0) return r(t, o);
+				let s = E(a);
+				if (s.id !== "validation.invalid") {
+					n(t, s.id, s.params, A(e));
+					return;
+				}
+				if (e.issue !== void 0 && (e.issue._tag === "Pointer" || e.issue._tag === "Composite" || e.issue._tag === "Type")) {
+					i(e.issue, t);
+					return;
+				}
+				n(t, "validation.invalid", void 0, A(e));
+				return;
+			}
+			case "Transformation":
+				e.issue !== void 0 && i(e.issue, t);
+				return;
+			case "Missing":
+				n(t, "validation.required", void 0, "Required");
+				return;
+			case "Type": {
+				if (typeof e.message == "string" && e.message.length > 0) return r(t, e.message);
+				let i = e.ast?.annotations, a = i === void 0 ? void 0 : D(i, e);
+				if (a !== void 0) return r(t, a);
+				n(t, "validation.invalid", void 0, A(e));
+				return;
+			}
+			default:
+				n(t, "validation.invalid", void 0, A(e));
+				return;
+		}
+	};
+	return i(e.issue, []), t;
+}, A = (e) => typeof e.message == "string" && e.message.length > 0 ? e.message : "Invalid value", j = (e, t) => {
+	if (typeof t != "object" || !t || Array.isArray(t)) return {
+		input: t,
+		dropped: []
+	};
+	let r;
+	try {
+		r = n.getPropertySignatures(e.ast).map((e) => String(e.name));
+	} catch {
+		return {
+			input: t,
+			dropped: []
+		};
+	}
+	if (r.length === 0) return {
+		input: t,
+		dropped: []
+	};
+	let i = new Set(r), a = Object.entries(t), o = a.filter(([e]) => !i.has(e)).map(([e]) => e);
+	return o.length === 0 ? {
+		input: t,
+		dropped: []
+	} : {
+		input: Object.fromEntries(a.filter(([e]) => i.has(e))),
+		dropped: o
+	};
+}, M = (e, n, r) => {
+	let i = t.decodeUnknownEither(e, { errors: "all" })(n);
+	if (i._tag === "Right") return {
+		valid: !0,
+		errors: {},
+		issues: []
+	};
+	let a = k(i.left).map((t) => {
+		if (t.id !== "validation.minLength" && t.id !== "validation.maxLength") return t;
+		let n = T(e, t.path);
+		return n.min === void 0 || n.max === void 0 ? t : n.min === n.max ? {
+			...t,
+			id: "validation.exactLength",
+			params: { amount: n.min }
+		} : {
+			...t,
+			id: "validation.betweenLength",
+			params: {
+				min: n.min,
+				max: n.max
+			}
+		};
+	}), o = {};
+	for (let e of a) e.path !== "" && !(e.path in o) && (o[e.path] = S(e, r));
+	return {
+		valid: !1,
+		errors: o,
+		issues: a
+	};
+}, N = [
+	"bold",
+	"italic",
+	"code",
+	"strike"
+], te = 5e3, ne = (e) => {
+	let t = "";
+	for (let n of e) {
+		let e = n.codePointAt(0) ?? 0;
+		e > 32 && e !== 127 && (t += n);
+	}
+	return t.toLowerCase();
+}, P = (e) => {
+	let t = ne(e);
+	return t.length === 0 ? !1 : t.startsWith("#") || t.startsWith("/") ? !t.startsWith("//") : t.startsWith("https://") || t.startsWith("http://") || t.startsWith("mailto:");
+}, re = t.String.pipe(t.filter((e) => P(e) || "href must be http(s), mailto:, a #fragment or a /path")), F = t.Struct({
+	type: t.Literal("text"),
+	text: t.String,
+	marks: t.optional(t.Array(t.Literal(...N)))
+}), I = t.Struct({
+	type: t.Literal("link"),
+	href: re,
+	content: t.Array(F)
+}), L = t.Union(F, I), R = t.Struct({
+	type: t.Literal("listItem"),
+	content: t.Array(L)
+}), z = t.Union(t.Struct({
+	type: t.Literal("paragraph"),
+	content: t.Array(L)
+}), t.Struct({
+	type: t.Literal("heading"),
+	level: t.Literal(1, 2, 3),
+	content: t.Array(L)
+}), t.Struct({
+	type: t.Literal("blockquote"),
+	content: t.Array(L)
+}), t.Struct({
+	type: t.Literal("bulletList"),
+	content: t.Array(R)
+}), t.Struct({
+	type: t.Literal("orderedList"),
+	content: t.Array(R)
+}), t.Struct({
+	type: t.Literal("codeBlock"),
+	text: t.String
+})), B = (e) => {
+	let t = 1, n = (e) => {
+		for (let r of e) {
+			t += 1;
+			let e = r.content;
+			Array.isArray(e) && n(e);
+		}
+	};
+	return n(e.content), t;
+}, V = t.Struct({
+	type: t.Literal("doc"),
+	content: t.Array(z)
+}).pipe(t.filter((e) => B(e) <= 5e3 || "rich text document exceeds 5000 nodes"), t.annotations(r({ widget: "rich-text" }))), H = {
+	type: "doc",
+	content: []
+}, U = (e) => typeof e == "object" && !!e && e.type === "doc" && Array.isArray(e.content), W = /(\*\*([^*]+)\*\*)|(~~([^~]+)~~)|(\*([^*]+)\*)|(`([^`]+)`)|(\[([^\]]*)\]\(([^)\s]+)\))/, G = (e, t) => t && t.length > 0 ? {
+	type: "text",
+	text: e,
+	marks: t
+} : {
+	type: "text",
+	text: e
+}, K = (e) => {
+	let t = [], n = e;
+	for (;;) {
+		let e = W.exec(n);
+		if (e === null || e.index === void 0) break;
+		e.index > 0 && t.push(G(n.slice(0, e.index))), e[2] === void 0 ? e[4] === void 0 ? e[6] === void 0 ? e[8] === void 0 ? e[11] !== void 0 && (P(e[11]) ? t.push({
+			type: "link",
+			href: e[11],
+			content: [{
+				type: "text",
+				text: e[10] ?? ""
+			}]
+		}) : t.push(G(e[0]))) : t.push(G(e[8], ["code"])) : t.push(G(e[6], ["italic"])) : t.push(G(e[4], ["strike"])) : t.push(G(e[2], ["bold"])), n = n.slice(e.index + e[0].length);
+	}
+	return n.length > 0 && t.push(G(n)), t;
+}, q = (e, t) => e.map((e) => ({
+	type: "listItem",
+	content: K(e.replace(t, ""))
+})), J = (e) => {
+	if (e.length === 0) return null;
+	let t = e[0];
+	if (t.startsWith("```")) return {
+		type: "codeBlock",
+		text: e.slice(1).filter((e) => !e.startsWith("```")).join("\n")
+	};
+	let n = /^(#{1,3})\s+(.*)$/.exec(t);
+	return n === null ? e.every((e) => /^[-*]\s+/.test(e)) ? {
+		type: "bulletList",
+		content: q(e, /^[-*]\s+/)
+	} : e.every((e) => /^\d+\.\s+/.test(e)) ? {
+		type: "orderedList",
+		content: q(e, /^\d+\.\s+/)
+	} : e.every((e) => e.startsWith(">")) ? {
+		type: "blockquote",
+		content: K(e.map((e) => e.replace(/^>\s?/, "")).join(" "))
+	} : {
+		type: "paragraph",
+		content: K(e.join(" "))
+	} : {
+		type: "heading",
+		level: n[1].length,
+		content: K(n[2])
+	};
+}, Y = (e) => {
+	let t = [], n = [], r = () => {
+		let e = J(n);
+		e !== null && t.push(e), n = [];
+	};
+	for (let t of e.replace(/\r\n/g, "\n").split("\n")) t.trim() === "" ? r() : n.push(t);
+	return r(), {
+		type: "doc",
+		content: t
+	};
+}, X = (e) => e.map((e) => {
+	if (e.type === "link") return `[${e.content.map((e) => e.text).join("")}](${e.href})`;
+	let t = e.marks ?? [];
+	return t.includes("bold") ? `**${e.text}**` : t.includes("strike") ? `~~${e.text}~~` : t.includes("italic") ? `*${e.text}*` : t.includes("code") ? `\`${e.text}\`` : e.text;
+}).join(""), ie = (e) => U(e) ? e.content.map((e) => {
+	switch (e.type) {
+		case "heading": return `${"#".repeat(e.level)} ${X(e.content)}`;
+		case "bulletList": return e.content.map((e) => `- ${X(e.content)}`).join("\n");
+		case "orderedList": return e.content.map((e, t) => `${t + 1}. ${X(e.content)}`).join("\n");
+		case "blockquote": return `> ${X(e.content)}`;
+		case "codeBlock": return [
+			"```",
+			e.text,
+			"```"
+		].join("\n");
+		default: return X(e.content);
+	}
+}).join("\n\n") : "", ae = (e) => {
+	if (!U(e)) return "";
+	let t = (e) => e.map((e) => e.type === "link" ? e.content.map((e) => e.text).join("") : e.text).join("");
+	return e.content.map((e) => {
+		switch (e.type) {
+			case "bulletList":
+			case "orderedList": return e.content.map((e) => t(e.content)).join("\n");
+			case "codeBlock": return e.text;
+			default: return t(e.content);
+		}
+	}).join("\n\n");
+}, oe = "__voltro_form_flash__", Z = "/form/", se = (e) => `${Z}${encodeURIComponent(e)}`, Q = "__voltro_form", ce = "__voltro_redirect", $ = (e) => {
+	let t = Number(e);
+	return Number.isNaN(t) ? e : t;
+}, le = (e) => {
+	let t = e.jsonSchema.items;
+	if (!t || typeof t != "object") return;
+	let n = t.type;
+	return typeof n == "string" ? n : void 0;
+}, ue = (e, t) => {
+	switch (e.widget) {
+		case "rich-text": return t === "" ? {
+			type: "doc",
+			content: []
+		} : Y(t);
+		case "number": return t === "" ? void 0 : $(t);
+		case "date":
+		case "datetime": return t === "" ? void 0 : t;
+		default: return t;
+	}
+}, de = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	for (let [e, r] of t) {
+		let t = n.get(e);
+		t === void 0 ? n.set(e, [r]) : t.push(r);
+	}
+	let r = {}, i = (e, t) => {
+		let n = e.split("."), i = r;
+		for (let e of n.slice(0, -1)) {
+			let t = i[e];
+			if (typeof t != "object" || !t) {
+				let t = {};
+				i[e] = t, i = t;
+			} else i = t;
+		}
+		i[n[n.length - 1]] = t;
+	};
+	for (let t of g(e)) {
+		if (t.widget === "array") continue;
+		let e = n.get(t.name);
+		if (t.widget === "checkbox" || t.widget === "switch") {
+			i(t.name, e !== void 0);
+			continue;
+		}
+		if (t.widget === "multi-select") {
+			let n = le(t), r = e ?? [];
+			i(t.name, n === "number" || n === "integer" ? r.filter((e) => e !== "").map($) : r.filter((e) => e !== ""));
+			continue;
+		}
+		if (e === void 0) continue;
+		let r = ue(t, e[0]);
+		r !== void 0 && i(t.name, r);
+	}
+	return r;
+};
+//#endregion
+export { _ as C, v as S, x as _, se as a, M as b, te as c, U as d, P as f, k as g, ie as h, ce as i, V as l, ae as m, Q as n, de as o, Y as p, Z as r, N as s, oe as t, H as u, S as v, g as w, r as x, j as y };