npm - @voltro/client - Versions diffs - 0.52.0 → 0.53.0 - Mend

@voltro/client 0.52.0 → 0.53.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/CHANGELOG.md +229 -0
package/THIRD-PARTY-NOTICES.md +169 -1
package/dist/form.d.ts +111 -10
package/dist/form.js +2 -2
package/dist/formData-BO7zkG_F.js +386 -0
package/dist/index.d.ts +393 -16
package/dist/index.js +1157 -810
package/package.json +4 -2
package/dist/formData-Bw07C0wr.js +0 -155

package/dist/form.d.ts CHANGED Viewed

@@ -1,5 +1,17 @@
+import { ParseResult } from 'effect';
 import { Schema } from 'effect';
+/**
+ * Walk a ParseError's issue tree into structured, PATH-PRESERVING issues.
+ * Every leaf keeps its full path (`address.city`, `entries.0.startsAt`) —
+ * nothing collapses to the top-level segment.
+ */
+export declare const decodeFieldIssues: (error: ParseResult.ParseError) => ReadonlyArray<FieldIssue>;
+/** The document's locale per the framework contract (`<html lang>`); `'en'`
+ *  outside a browser. Primary subtag only (`de-AT` → `de`). */
+export declare const documentLocale: () => string;
 export declare interface FieldDescriptor {
     /** Property name on the input object. */
     readonly name: string;
@@ -16,17 +28,56 @@ export declare interface FieldDescriptor {
     /** The resolved JSON-Schema node — carries `maxLength` / `pattern` /
      *  `minimum` / `format` / `description` for widgets + validation hints. */
     readonly jsonSchema: Readonly<Record<string, unknown>>;
+    /** Dotted parent path for a nested-struct member (`'address'` for
+     *  `address.city`) — the SECTION a renderer groups it under. Top-level
+     *  fields carry none. Overridable via `formField({ section })`. */
+    readonly section?: string;
+    /** Human label for the section (humanised path tail). */
+    readonly sectionLabel?: string;
+    /** Help text — the Schema `description` annotation. */
+    readonly description?: string;
+    /** Declared ordering (`formField({ order })`); fields sort by it, stable
+     *  against declaration order. */
+    readonly order?: number;
+    /** For `widget: 'array'` (array of structs): the ITEM's field descriptors,
+     *  names relative to one item (`startsAt`, not `entries.0.startsAt`). */
+    readonly item?: ReadonlyArray<FieldDescriptor>;
+    /** For `widget: 'reference'`: the referenced TABLE — a renderer binds a
+     *  query-backed picker to it; the VALUE stays the id (or id list). Comes
+     *  from `formField({ reference: 'stores' })`. */
+    readonly reference?: string;
 }
 export declare interface FieldErrors {
     readonly [field: string]: string;
 }
+/** One structured validation issue. `path` is the dotted field path
+ *  (`'email'`, `'address.city'`, `'entries.0.startsAt'`); `id` is the stable
+ *  message id (`'validation.minLength'`); `params` feed its template;
+ *  `fallback` is a rendered English default so an unknown id still shows a
+ *  sentence, never a bare key. */
+export declare interface FieldIssue {
+    readonly path: string;
+    readonly id: string;
+    readonly params?: Readonly<Record<string, unknown>>;
+    readonly fallback: string;
+}
 export declare interface FieldOption {
     readonly value: string;
     readonly label: string;
 }
+/** One display section of a form: `name` is the section path (`'address'`),
+ *  `undefined` for the top-level run of unsectioned fields. Contiguous in
+ *  display order, so a renderer can walk sections top to bottom. */
+export declare interface FieldSection {
+    readonly name: string | undefined;
+    readonly label: string | undefined;
+    readonly fields: ReadonlyArray<FieldDescriptor>;
+}
 /** DOM id of the JSON script the 422 re-render embeds (survives the
  *  `interactive:'none'` strip — it is neither `type="module"` nor `src`). */
 export declare const FORM_FLASH_SCRIPT_ID = "__voltro_form_flash__";
@@ -68,6 +119,27 @@ export declare const formDataToInput: (schema: Schema.Schema.Any, entries: Itera
  *  uploads are a declared limit of the no-JS path. */
 export declare type FormEntry = readonly [name: string, value: string];
+/** UI metadata for one schema field, as an annotations object:
+ *
+ *     Schema.String.annotations(formField({ section: 'contact', order: 2 }))
+ *
+ * Rides the JSON-Schema annotation (merged, not replaced — verified), so it
+ * survives the same normalisation every other descriptor fact does. */
+export declare const formField: (meta: {
+    readonly label?: string;
+    readonly section?: string;
+    readonly order?: number;
+    readonly widget?: WidgetKind;
+    /** Mark the field a REFERENCE to a table: `formField({ reference: 'stores' })`
+     *  → `widget: 'reference'` carrying the target, value = the id (or id
+     *  list, for a multi-reference feeding a target's `relations:`). */
+    readonly reference?: string;
+}) => {
+    readonly jsonSchema: {
+        readonly "x-voltro": typeof meta;
+    };
+};
 /**
  * The error/values payload a failed no-JS form POST carries back into the
  * 422 re-render. Keyed by `formKey` so a page with several forms re-fills
@@ -87,6 +159,21 @@ export declare interface FormFlashPayload {
     readonly formError?: string;
 }
+/**
+ * Group an ordered field list into contiguous sections — the structure a
+ * form (or its skeleton — the placeholder must have the SHAPE of the real
+ * thing, title rows included) renders. Pure; feeds `<FormSkeleton>`,
+ * `<AutoForm>` layouts and `form.section(...)` alike.
+ */
+export declare const formSections: (fields: ReadonlyArray<FieldDescriptor>) => ReadonlyArray<FieldSection>;
+/**
+ * Render one issue id to display text: app resolver first (its `undefined`
+ * falls through), then the built-in catalog for the locale's primary subtag,
+ * then English, then the issue's own fallback sentence.
+ */
+export declare const resolveValidationMessage: (issue: Pick<FieldIssue, "id" | "params" | "fallback">, options?: ValidateOptions) => string;
 /**
  * Derive table COLUMNS from a query's output `Schema` — an
  * `Schema.Array(Schema.Struct({...}))`. Drills into the array's element and maps
@@ -103,25 +190,39 @@ export declare const schemaToColumns: (schema: Schema.Schema.Any) => ReadonlyArr
 export declare const schemaToFields: (schema: Schema.Schema.Any) => ReadonlyArray<FieldDescriptor>;
 /**
- * Validate `values` against an input `schema`, returning the first error per
- * top-level field (`{ [field]: message }`) — the shape `<AutoForm>` and custom
- * widgets render inline. Uses the same `decodeUnknownEither` + `ArrayFormatter`
- * path the store's `.validate(...)` uses, so client and server speak ONE
- * schema. `{ errors: 'all' }` collects every field's error in one pass.
- *
- * Client-side validation is non-authoritative UX — the server re-validates the
- * same schema on the mutation; this just gives instant inline feedback.
+ * Validate `values` against an input `schema`. Uses the same
+ * `decodeUnknownEither` path the store's `.validate(...)` uses, so client and
+ * server speak ONE schema; `{ errors: 'all' }` collects every field in one
+ * pass. Client-side validation is non-authoritative UX — the server
+ * re-validates the same schema on the mutation.
  */
-export declare const validateFields: (schema: Schema.Schema.Any, values: unknown) => ValidationResult;
+export declare const validateFields: (schema: Schema.Schema.Any, values: unknown, options?: ValidateOptions) => ValidationResult;
+export declare interface ValidateOptions {
+    /** BCP-47-ish tag; only the primary subtag is read. Default: the document's
+     *  `<html lang>`, else `'en'`. */
+    readonly locale?: string;
+    readonly messages?: ValidationMessageResolver;
+}
+/** Resolve one message id to display text. Return `undefined` to fall through
+ *  to the built-in en/de defaults — so a resolver only has to know the ids it
+ *  overrides. Wire it to `@voltro/i18n` in one line:
+ *  `messages: (id, params) => t(id, params)`. */
+export declare type ValidationMessageResolver = (id: string, params: Readonly<Record<string, unknown>> | undefined, fallback: string) => string | undefined;
 export declare interface ValidationResult {
     readonly valid: boolean;
+    /** Display text per field path — what `<AutoForm>` and custom widgets
+     *  render inline. First issue per field wins. */
     readonly errors: FieldErrors;
+    /** Every issue, structured — for widget kits that translate themselves. */
+    readonly issues: ReadonlyArray<FieldIssue>;
 }
 /** 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' | 'custom';
+export declare type WidgetKind = 'text' | 'textarea' | 'number' | 'checkbox' | 'switch' | 'select' | 'radio' | 'async-select' | 'multi-select' | 'date' | 'datetime' | 'daterange' | 'file' | 'hidden' | 'array' | 'reference' | 'custom';
 export { }

package/dist/form.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./formData-Bw07C0wr.js";
-export { c as FORM_FLASH_SCRIPT_ID, i as FORM_KEY_FIELD, o as FORM_PATH_PREFIX, n as FORM_REDIRECT_FIELD, e as formActionPath, a as formDataToInput, t as schemaToColumns, r as schemaToFields, s as validateFields };
+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 };

package/dist/formData-BO7zkG_F.js ADDED Viewed

@@ -0,0 +1,386 @@
+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" };
+	}
+}, d = (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";
+}, f = (e) => typeof e["x-voltro"] == "object" && e["x-voltro"] !== null ? e["x-voltro"] : {}, p = 4, m = (e, t, n, r = "", i, s = 0) => Object.entries(e).flatMap(([e, l]) => {
+	let { node: h, nullable: g } = c(o(l, n), n), _ = o(h, n), v = f(_), y = r === "" ? e : `${r}.${e}`, b = _.properties;
+	if (_.type === "object" && b !== void 0 && s < p && v.widget === void 0) return m(b, new Set(Array.isArray(_.required) ? _.required : []), n, y, {
+		path: v.section ?? y,
+		label: v.label ?? a(e)
+	}, s + 1);
+	let x = d(l), { widget: S, options: C } = u(_);
+	x !== void 0 && (S = x);
+	let w;
+	if (_.type === "array") {
+		let e = _.items;
+		if (typeof e == "object" && e && !Array.isArray(e)) {
+			let t = o(e, n), r = t.properties;
+			t.type === "object" && r !== void 0 && (S = "array", w = m(r, new Set(Array.isArray(t.required) ? t.required : []), n));
+		}
+	}
+	v.widget !== void 0 && (S = v.widget), v.reference !== void 0 && v.widget === void 0 && (S = "reference");
+	let T = typeof _.description == "string" ? _.description : void 0, E = v.section ?? i?.path;
+	return [{
+		name: y,
+		label: v.label ?? a(e),
+		widget: S,
+		required: t.has(e),
+		nullable: g,
+		...C ? { options: C } : {},
+		jsonSchema: _,
+		...E === void 0 ? {} : {
+			section: E,
+			sectionLabel: i?.label ?? a(E)
+		},
+		...T === void 0 ? {} : { description: T },
+		...v.order === void 0 ? {} : { order: v.order },
+		...w === void 0 ? {} : { item: w },
+		...v.reference === void 0 ? {} : { reference: v.reference }
+	}];
+}), h = (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), g = (t) => {
+	try {
+		return e.make(t);
+	} catch {
+		return;
+	}
+}, _ = (e) => {
+	let t = g(e);
+	if (t === void 0) return [];
+	let n = t.$defs ?? {}, r = o(t, n), i = r.properties;
+	return i ? h(m(i, new Set(Array.isArray(r.required) ? r.required : []), n)) : [];
+}, v = (e) => {
+	let t = g(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 ? m(s, new Set(Array.isArray(a.required) ? a.required : []), n) : [];
+}, y = (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;
+}, b = {
+	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…"
+	},
+	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…"
+	}
+}, x = (e, t) => e.replace(/\{(\w+)\}/g, (e, n) => {
+	let r = t?.[n];
+	return r === void 0 ? e : String(r);
+}), S = () => {
+	let e = globalThis.document?.documentElement?.lang ?? "";
+	return e === "" ? "en" : e;
+}, C = (e, t) => {
+	let n = t?.messages?.(e.id, e.params, e.fallback);
+	if (n !== void 0) return n;
+	let r = b[(t?.locale ?? S()).toLowerCase().split("-")[0] ?? "en"]?.[e.id] ?? b.en?.[e.id];
+	return r === void 0 ? e.fallback : x(r, e.params);
+}, w = (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
+	};
+}, T = (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.PatternSchemaId: return {
+			id: "validation.pattern",
+			params: { pattern: i.pattern }
+		};
+		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: { min: i.minItems }
+		};
+		case t.MaxItemsSchemaId: return {
+			id: "validation.maxItems",
+			params: { max: i.maxItems }
+		};
+		case t.BetweenSchemaId: return {
+			id: "validation.minValue",
+			params: {
+				min: i.minimum,
+				max: i.maximum
+			}
+		};
+		default: return { id: "validation.invalid" };
+	}
+}, E = (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 {}
+}, D = (e) => Array.isArray(e) ? e.map((e) => String(e)) : [String(e)], O = (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 = w(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, ...D(e.path)]);
+				return;
+			case "Refinement": {
+				if (e.kind === "From") {
+					e.issue !== void 0 && i(e.issue, t);
+					return;
+				}
+				let a = e.ast?.annotations ?? {}, o = E(a, e);
+				if (o !== void 0) return r(t, o);
+				let s = T(a);
+				if (s.id !== "validation.invalid") {
+					n(t, s.id, s.params, k(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, k(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 : E(i, e);
+				if (a !== void 0) return r(t, a);
+				n(t, "validation.invalid", void 0, k(e));
+				return;
+			}
+			default:
+				n(t, "validation.invalid", void 0, k(e));
+				return;
+		}
+	};
+	return i(e.issue, []), t;
+}, k = (e) => typeof e.message == "string" && e.message.length > 0 ? e.message : "Invalid value", A = (e, n, r) => {
+	let i = t.decodeUnknownEither(e, { errors: "all" })(n);
+	if (i._tag === "Right") return {
+		valid: !0,
+		errors: {},
+		issues: []
+	};
+	let a = O(i.left), o = {};
+	for (let e of a) e.path !== "" && !(e.path in o) && (o[e.path] = C(e, r));
+	return {
+		valid: !1,
+		errors: o,
+		issues: a
+	};
+}, j = "__voltro_form_flash__", M = "/form/", N = (e) => `${M}${encodeURIComponent(e)}`, P = "__voltro_form", F = "__voltro_redirect", I = (e) => {
+	let t = Number(e);
+	return Number.isNaN(t) ? e : t;
+}, L = (e) => {
+	let t = e.jsonSchema.items;
+	if (!t || typeof t != "object") return;
+	let n = t.type;
+	return typeof n == "string" ? n : void 0;
+}, R = (e, t) => {
+	switch (e.widget) {
+		case "number": return t === "" ? void 0 : I(t);
+		case "date":
+		case "datetime": return t === "" ? void 0 : t;
+		default: return t;
+	}
+}, z = (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 _(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 = L(t), r = e ?? [];
+			i(t.name, n === "number" || n === "integer" ? r.filter((e) => e !== "").map(I) : r.filter((e) => e !== ""));
+			continue;
+		}
+		if (e === void 0) continue;
+		let r = R(t, e[0]);
+		r !== void 0 && i(t.name, r);
+	}
+	return r;
+};
+//#endregion
+export { N as a, S as c, r as d, y as f, F as i, C as l, _ as m, P as n, z as o, v as p, M as r, O as s, j as t, A as u };