@10x-media/form-builder 0.1.0-beta.0

package/dist/resolver-OeQyVH2N.js

@@ -0,0 +1,665 @@
+import { t as keys } from "./keys-N5xGiUsh.js";
+import { s as labelFor } from "./registry-CoCyhtvB.js";
+import { transformWhereQuery } from "payload/shared";
+//#region src/recall/interpolate.ts
+const TOKEN = /\{\{\s*([^{}|]+?)\s*(?:\|([^{}]*?))?\}\}/g;
+/**
+* Replace `{{ name }}` and `{{ name|fallback }}` tokens. `resolve` returns the recalled value (''
+* when absent); the fallback (or '') is substituted when `resolve` yields ''. Token-free input is
+* returned unchanged, so this is a no-op for ordinary text.
+*/
+const interpolate = (template, resolve) => template.replace(TOKEN, (_match, rawName, rawFallback) => {
+	const value = resolve(rawName.trim());
+	if (value !== "") return value;
+	return rawFallback === void 0 ? "" : rawFallback.trim();
+});
+//#endregion
+//#region src/events/noopSink.ts
+const noopEventSink = { emit: () => Promise.resolve() };
+//#endregion
+//#region src/spam/constants.ts
+/** Default honeypot decoy field name. Plausible to bots, unlikely to collide with a real field name. */
+const DEFAULT_HONEYPOT_FIELD = "confirm_email";
+/** Reserved `values` entry carrying a captcha token from the client. */
+const CAPTCHA_TOKEN_KEY = "__fb_captcha";
+/** `req.context` key under which the spam guard stashes the resolved identity for upload-ownership verification. */
+const IDENTITY_CONTEXT_KEY = "formBuilderSpamIdentity";
+//#endregion
+//#region src/presentations/defaults.ts
+const DEFAULT_PRESENTATION_NAME = "page";
+const defaultPresentationDescriptors = {
+	page: {
+		name: "page",
+		label: keys.presentationPage,
+		surface: "page",
+		density: "comfortable"
+	},
+	inline: {
+		name: "inline",
+		label: keys.presentationInline,
+		surface: "inline",
+		density: "comfortable"
+	},
+	modal: {
+		name: "modal",
+		label: keys.presentationModal,
+		surface: "overlay",
+		density: "comfortable",
+		dismissOnSuccess: true
+	},
+	drawer: {
+		name: "drawer",
+		label: keys.presentationDrawer,
+		surface: "overlay",
+		density: "comfortable",
+		dismissOnSuccess: true
+	}
+};
+//#endregion
+//#region src/calc/evaluate.ts
+const MAX_DEPTH = 64;
+const toNumber$1 = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value : 0;
+	if (typeof value === "string" && value.trim() !== "") {
+		const n = Number(value);
+		return Number.isFinite(n) ? n : 0;
+	}
+	return 0;
+};
+const finite = (n) => Number.isFinite(n) ? n : 0;
+const FUNCTIONS = {
+	min: (a) => a.length ? Math.min(...a) : 0,
+	max: (a) => a.length ? Math.max(...a) : 0,
+	round: (a) => Math.round(a[0] ?? 0),
+	abs: (a) => Math.abs(a[0] ?? 0),
+	ceil: (a) => Math.ceil(a[0] ?? 0),
+	floor: (a) => Math.floor(a[0] ?? 0)
+};
+const evalNode = (expr, answers, depth) => {
+	if (depth > MAX_DEPTH || expr == null || typeof expr !== "object") return 0;
+	switch (expr.type) {
+		case "lit": return finite(toNumber$1(expr.value));
+		case "ref": return toNumber$1(answers[expr.field]);
+		case "neg": return finite(-evalNode(expr.operand, answers, depth + 1));
+		case "op": {
+			const l = evalNode(expr.left, answers, depth + 1);
+			const r = evalNode(expr.right, answers, depth + 1);
+			switch (expr.op) {
+				case "+": return finite(l + r);
+				case "-": return finite(l - r);
+				case "*": return finite(l * r);
+				case "/": return r === 0 ? 0 : finite(l / r);
+				case "%": return r === 0 ? 0 : finite(l % r);
+				default: return 0;
+			}
+		}
+		case "fn": {
+			const fn = FUNCTIONS[expr.fn];
+			if (!fn) return 0;
+			return finite(fn(Array.isArray(expr.args) ? expr.args.map((a) => evalNode(a, answers, depth + 1)) : []));
+		}
+		case "weight": {
+			const weights = expr.weights ?? {};
+			const value = answers[expr.field];
+			return finite((Array.isArray(value) ? value : value == null || value === "" ? [] : [value]).reduce((sum, v) => sum + toNumber$1(weights[String(v)]), 0));
+		}
+		default: return 0;
+	}
+};
+/** Evaluate a calc expression against form answers. Total + safe: no `eval`, always finite, div/mod by zero -> 0, missing ref -> 0, depth-guarded. Isomorphic (client + server). */
+const evaluateCalc = (expr, answers) => {
+	if (!expr) return 0;
+	return evalNode(expr, answers, 0);
+};
+//#endregion
+//#region src/calc/computeCalcFields.ts
+/** Returns the calc expression if the field carries one (non-null object), otherwise undefined. */
+const calcExpressionOf = (field) => {
+	const expr = field.expression;
+	return expr !== null && typeof expr === "object" && !Array.isArray(expr) ? expr : void 0;
+};
+/**
+* Returns answers with every calc field's value derived from its expression,
+* folded in declaration order so a calc may reference an earlier calc's result.
+* Identity when no field carries an expression.
+*/
+const computeCalcFields = (fields, answers) => {
+	let next = answers;
+	for (const field of fields) {
+		const expr = calcExpressionOf(field);
+		if (expr) next = {
+			...next,
+			[field.name]: evaluateCalc(expr, next)
+		};
+	}
+	return next;
+};
+//#endregion
+//#region src/conditions/evaluate.ts
+const isNil = (value) => value === null || value === void 0;
+const toNumber = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value === "string" && value.trim() !== "") {
+		const next = Number(value);
+		return Number.isNaN(next) ? void 0 : next;
+	}
+};
+const toTime = (value) => {
+	if (value instanceof Date) return value.getTime();
+	if (typeof value === "string" && value.trim() !== "") {
+		const time = Date.parse(value);
+		return Number.isNaN(time) ? void 0 : time;
+	}
+};
+/** Strict, then numeric, then string equality, mirroring Payload's coerce-by-type-then-compare. */
+const valuesEqual = (answer, value) => {
+	if (answer === value) return true;
+	if (isNil(answer) || isNil(value)) return false;
+	const a = toNumber(answer);
+	const b = toNumber(value);
+	if (a !== void 0 && b !== void 0) return a === b;
+	return String(answer) === String(value);
+};
+const toList = (value) => {
+	if (Array.isArray(value)) return value;
+	if (typeof value === "string") return value.split(",").map((entry) => entry.trim());
+	return [value];
+};
+const ordered = (answer, value, compare) => {
+	const a = toNumber(answer) ?? toTime(answer);
+	const b = toNumber(value) ?? toTime(value);
+	if (a === void 0 || b === void 0) return false;
+	return compare(a, b);
+};
+/** Case-insensitive: every space-separated word in `value` is a substring of `answer` (Payload `like`). */
+const everyWord = (answer, value) => {
+	const haystack = String(answer).toLowerCase();
+	return String(value).toLowerCase().split(" ").filter((word) => word.length > 0).every((word) => haystack.includes(word));
+};
+const evaluateOperator = (operator, answer, value) => {
+	switch (operator) {
+		case "equals": return isNil(value) ? isNil(answer) : valuesEqual(answer, value);
+		case "not_equals": return isNil(value) ? !isNil(answer) : isNil(answer) || !valuesEqual(answer, value);
+		case "in": return toList(value).some((entry) => valuesEqual(answer, entry));
+		case "not_in": return isNil(answer) || !toList(value).some((entry) => valuesEqual(answer, entry));
+		case "exists": {
+			const present = !isNil(answer) && answer !== "";
+			return value === true || value === "true" ? present : !present;
+		}
+		case "greater_than": return ordered(answer, value, (a, b) => a > b);
+		case "greater_than_equal": return ordered(answer, value, (a, b) => a >= b);
+		case "less_than": return ordered(answer, value, (a, b) => a < b);
+		case "less_than_equal": return ordered(answer, value, (a, b) => a <= b);
+		case "like": return isNil(answer) ? false : everyWord(answer, value);
+		case "not_like": return isNil(answer) ? true : !everyWord(answer, value);
+		case "contains": return isNil(answer) ? false : String(answer).toLowerCase().includes(String(value).toLowerCase());
+		default: return false;
+	}
+};
+/**
+* Evaluate one `Where` node: every top-level key is ANDed. `or` is a disjunction of sub-conditions
+* (an empty `or` matches), `and` is a conjunction, and any other key is a field path whose
+* `{ operator: value }` constraints are ANDed. Recurses, so nested `or`/`and` groups are supported.
+*/
+const evaluateWhere = (where, answers) => Object.entries(where).every(([key, constraint]) => {
+	if (key === "or") {
+		const groups = Array.isArray(constraint) ? constraint : [];
+		return groups.length === 0 || groups.some((group) => evaluateWhere(group, answers));
+	}
+	if (key === "and") return (Array.isArray(constraint) ? constraint : []).every((group) => evaluateWhere(group, answers));
+	if (constraint == null || typeof constraint !== "object" || Array.isArray(constraint)) return false;
+	return Object.entries(constraint).every(([operator, value]) => evaluateOperator(operator, answers[key], value));
+});
+/**
+* Evaluate a serializable `Where`-shaped condition against a flat map of (already coerced) form answers.
+* An absent or empty condition matches (returns true). Operator semantics mirror Payload's query
+* adapters: coerce then compare; `not_equals`/`not_in` are null-inclusive; `exists` treats `''`/absent
+* as not-existing; `like` is case-insensitive and space-splits (every word must be a substring), and
+* `not_like` is its logical negation (at least one word absent); `contains` is a single case-insensitive
+* substring; comma-delimited `in`/`not_in` string values are split and trimmed. Geo (`near`/`within`/
+* `intersects`) and `all` are out of scope and evaluate to false. Isomorphic: no `req`/DB access, so the
+* renderer reuses it client-side.
+*/
+const evaluateCondition = (where, answers) => {
+	if (!where || Object.keys(where).length === 0) return true;
+	return evaluateWhere(transformWhereQuery(where), answers);
+};
+//#endregion
+//#region src/validation/message.ts
+/** Replace `{key}` placeholders with `String(vars[key])`; unknown placeholders are left as-is. */
+const resolveMessage = (template, vars) => template.replace(/\{(\w+)\}/g, (match, key) => Object.hasOwn(vars, key) ? String(vars[key]) : match);
+/**
+* Race a (possibly async) rule against a deadline so a hung server rule cannot stall the submit path.
+* On timeout the `fallback` is resolved (the engine treats a timed-out rule as a non-blocking skip).
+*/
+const withTimeout = (promise, ms, fallback) => Promise.race([promise, new Promise((resolve) => {
+	setTimeout(() => resolve(fallback), ms);
+})]);
+//#endregion
+//#region src/validation/runValidation.ts
+const RULE_TIMEOUT_MS = 5e3;
+const isEmpty = (value) => value == null || value === "" || Array.isArray(value) && value.length === 0;
+/** Build the per-instance message resolver: custom override (a literal template) or the localized default. */
+const makeMessage = (instance, defaultMessageKey, t) => {
+	const { blockType: _blockType, message: _message, severity: _severity, ...params } = instance;
+	const template = typeof instance.message === "string" && instance.message.length > 0 ? instance.message : t(defaultMessageKey);
+	return (vars = {}) => resolveMessage(template, {
+		...params,
+		...vars
+	});
+};
+const toIssue = (result, fallbackSeverity) => {
+	if (result === true) return null;
+	if (typeof result === "string") return {
+		message: result,
+		severity: fallbackSeverity
+	};
+	return {
+		message: result.message,
+		severity: result.severity ?? fallbackSeverity
+	};
+};
+/**
+* The one validation engine, run per field on client and server. Order: required, the field type's
+* intrinsic validator, then each declarative rule instance. Server-only rules are skipped in client
+* mode; every rule is wrapped in try/catch + a timeout so a bad rule cannot crash or stall the submit
+* path (a thrown or timed-out rule fails open, logged on the server). Only `error`-severity issues
+* block submission; the caller filters severity.
+*/
+const runValidation = async (input) => {
+	const { field, fieldDefinition, value, fieldType, ruleRegistry, answers, locale, t, operation, event, mode, req, payload, formId, timeoutMs } = input;
+	const timeout = timeoutMs ?? RULE_TIMEOUT_MS;
+	const errors = [];
+	if (field.required && isEmpty(value)) return { errors: [{
+		message: t(keys.validationRequired),
+		severity: "error"
+	}] };
+	if (isEmpty(value)) return { errors: [] };
+	if (fieldDefinition?.validate) try {
+		const ran = fieldDefinition.validate({
+			value,
+			config: field,
+			siblingData: answers,
+			data: answers,
+			locale,
+			t
+		});
+		const result = ran instanceof Promise ? await withTimeout(ran, timeout, true) : ran;
+		if (result !== true) errors.push({
+			message: result,
+			severity: "error"
+		});
+	} catch (error) {
+		req?.payload?.logger?.error?.({
+			err: error,
+			field: field.name
+		}, "form-builder intrinsic field validator threw");
+	}
+	if (fieldDefinition?.schema) try {
+		const outcome = await fieldDefinition.schema["~standard"].validate(value);
+		if (outcome.issues) for (const issue of outcome.issues) errors.push({
+			message: issue.message,
+			severity: "error"
+		});
+	} catch (error) {
+		req?.payload?.logger?.error?.({
+			err: error,
+			field: field.name
+		}, "form-builder field schema threw");
+	}
+	const instances = Array.isArray(field.validations) ? field.validations : [];
+	for (const instance of instances) {
+		const rule = ruleRegistry.get(instance.blockType);
+		if (!rule) continue;
+		if (mode === "client" && rule.client === false) continue;
+		const message = makeMessage(instance, rule.defaultMessage, t);
+		const fallbackSeverity = instance.severity ?? rule.severity ?? "error";
+		try {
+			const ran = rule.validate({
+				value,
+				params: instance,
+				siblingData: answers,
+				data: answers,
+				field,
+				fieldType,
+				operation,
+				event,
+				locale,
+				message,
+				req: mode === "server" ? req : void 0,
+				payload: mode === "server" ? payload : void 0,
+				formId: mode === "server" ? formId : void 0
+			});
+			const issue = toIssue(ran instanceof Promise ? await withTimeout(ran, timeout, true) : ran, fallbackSeverity);
+			if (issue) errors.push(issue);
+		} catch (error) {
+			req?.payload?.logger?.error?.({
+				err: error,
+				rule: rule.type
+			}, "form-builder validation rule threw");
+		}
+	}
+	return { errors };
+};
+//#endregion
+//#region src/validation/defineValidationRule.ts
+/**
+* Define a validation rule type once: its `params` become a Payload `Field[]` in the per-field
+* constraint list, its typed `validate` runs in the one engine on client and server. Built-in rules
+* use this same primitive, so custom rules are never second-class.
+*/
+const defineValidationRule = (rule) => rule;
+//#endregion
+//#region src/validation/builtin/email.ts
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const emailRule = defineValidationRule({
+	type: "email",
+	label: keys.ruleEmail,
+	appliesTo: [
+		"text",
+		"textarea",
+		"email"
+	],
+	defaultMessage: keys.ruleEmailMessage,
+	validate: ({ value, message }) => value == null || value === "" || EMAIL_PATTERN.test(value) ? true : message()
+});
+//#endregion
+//#region src/validation/builtin/matchesField.ts
+const matchesFieldRule = defineValidationRule({
+	type: "matchesField",
+	label: keys.ruleMatchesField,
+	params: [{
+		name: "field",
+		type: "text",
+		required: true,
+		label: labelFor(keys.ruleParamField)
+	}],
+	defaultMessage: keys.ruleMatchesFieldMessage,
+	validate: ({ value, params, siblingData, message }) => value === siblingData[params.field] ? true : message()
+});
+//#endregion
+//#region src/validation/builtin/max.ts
+const maxRule = defineValidationRule({
+	type: "max",
+	label: keys.ruleMax,
+	appliesTo: ["number"],
+	params: [{
+		name: "max",
+		type: "number",
+		required: true,
+		label: labelFor(keys.ruleParamMax)
+	}],
+	defaultMessage: keys.ruleMaxMessage,
+	validate: ({ value, params, message }) => value == null || value <= params.max ? true : message({ max: params.max })
+});
+//#endregion
+//#region src/validation/builtin/maxLength.ts
+const maxLengthRule = defineValidationRule({
+	type: "maxLength",
+	label: keys.ruleMaxLength,
+	appliesTo: [
+		"text",
+		"textarea",
+		"email"
+	],
+	params: [{
+		name: "max",
+		type: "number",
+		required: true,
+		min: 0,
+		label: labelFor(keys.ruleParamMax)
+	}],
+	defaultMessage: keys.ruleMaxLengthMessage,
+	validate: ({ value, params, message }) => value == null || value === "" || value.length <= params.max ? true : message({ max: params.max })
+});
+//#endregion
+//#region src/validation/builtin/min.ts
+const minRule = defineValidationRule({
+	type: "min",
+	label: keys.ruleMin,
+	appliesTo: ["number"],
+	params: [{
+		name: "min",
+		type: "number",
+		required: true,
+		label: labelFor(keys.ruleParamMin)
+	}],
+	defaultMessage: keys.ruleMinMessage,
+	validate: ({ value, params, message }) => value == null || value >= params.min ? true : message({ min: params.min })
+});
+//#endregion
+//#region src/validation/builtin/minLength.ts
+const minLengthRule = defineValidationRule({
+	type: "minLength",
+	label: keys.ruleMinLength,
+	appliesTo: [
+		"text",
+		"textarea",
+		"email"
+	],
+	params: [{
+		name: "min",
+		type: "number",
+		required: true,
+		min: 0,
+		label: labelFor(keys.ruleParamMin)
+	}],
+	defaultMessage: keys.ruleMinLengthMessage,
+	validate: ({ value, params, message }) => value == null || value === "" || value.length >= params.min ? true : message({ min: params.min })
+});
+//#endregion
+//#region src/validation/builtin/notAlreadySubmitted.ts
+const FORM_SUBMISSIONS_SLUG = "form-submissions";
+const SCAN_LIMIT = 500;
+/**
+* Server-only async exemplar: rejects a value already present for the same form. Scans up to
+* `SCAN_LIMIT` recent submissions in JS (the values live in a json column, so a portable DB query is
+* not available); a future phase can add an indexed dedup column for scale.
+*/
+const notAlreadySubmittedRule = defineValidationRule({
+	type: "notAlreadySubmitted",
+	label: keys.ruleNotAlreadySubmitted,
+	client: false,
+	defaultMessage: keys.ruleNotAlreadySubmittedMessage,
+	validate: async ({ value, field, payload, req, formId, message }) => {
+		if (value == null || value === "" || !payload || formId == null) return true;
+		return (await payload.find({
+			collection: FORM_SUBMISSIONS_SLUG,
+			where: { form: { equals: formId } },
+			limit: SCAN_LIMIT,
+			depth: 0,
+			req
+		})).docs.some((doc) => {
+			return (doc.values ?? []).some((entry) => entry.field === field.name && entry.value === value);
+		}) ? message() : true;
+	}
+});
+//#endregion
+//#region src/validation/builtin/oneOf.ts
+const oneOfRule = defineValidationRule({
+	type: "oneOf",
+	label: keys.ruleOneOf,
+	appliesTo: [
+		"text",
+		"textarea",
+		"select"
+	],
+	params: [{
+		name: "values",
+		type: "array",
+		label: labelFor(keys.ruleParamValues),
+		fields: [{
+			name: "value",
+			type: "text",
+			required: true
+		}]
+	}],
+	defaultMessage: keys.ruleOneOfMessage,
+	validate: ({ value, params, message }) => {
+		if (value == null || value === "") return true;
+		const allowed = (params.values ?? []).map((entry) => entry.value);
+		if (allowed.length === 0) return true;
+		return allowed.includes(value) ? true : message();
+	}
+});
+//#endregion
+//#region src/validation/builtin/pattern.ts
+const tryRegExp = (pattern, flags) => {
+	try {
+		return new RegExp(pattern, flags);
+	} catch {
+		return;
+	}
+};
+const patternRule = defineValidationRule({
+	type: "pattern",
+	label: keys.rulePattern,
+	appliesTo: [
+		"text",
+		"textarea",
+		"email"
+	],
+	params: [{
+		name: "pattern",
+		type: "text",
+		required: true,
+		label: labelFor(keys.ruleParamPattern)
+	}, {
+		name: "flags",
+		type: "text",
+		label: labelFor(keys.ruleParamFlags)
+	}],
+	defaultMessage: keys.rulePatternMessage,
+	validate: ({ value, params, message }) => {
+		if (value == null || value === "") return true;
+		const regex = tryRegExp(params.pattern, params.flags);
+		if (!regex) return true;
+		return regex.test(value) ? true : message();
+	}
+});
+//#endregion
+//#region src/validation/builtin/url.ts
+const isUrl = (value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/validation/builtin/index.ts
+const defaultValidationRules = [
+	minLengthRule,
+	maxLengthRule,
+	minRule,
+	maxRule,
+	patternRule,
+	emailRule,
+	defineValidationRule({
+		type: "url",
+		label: keys.ruleUrl,
+		appliesTo: ["text", "textarea"],
+		defaultMessage: keys.ruleUrlMessage,
+		validate: ({ value, message }) => value == null || value === "" || isUrl(value) ? true : message()
+	}),
+	oneOfRule,
+	matchesFieldRule,
+	notAlreadySubmittedRule
+];
+//#endregion
+//#region src/validation/registry.ts
+const buildRuleRegistry = (rules) => {
+	const registry = /* @__PURE__ */ new Map();
+	for (const rule of rules) registry.set(rule.type, rule);
+	return registry;
+};
+/** Resolve the active rule registry from the built-in defaults and the plugin `rules` option. */
+const resolveValidationRules = (defaults, config = {}) => {
+	const registry = buildRuleRegistry(defaults);
+	for (const [type, option] of Object.entries(config)) if (option === false) registry.delete(type);
+	else if (option === true) {} else registry.set(type, {
+		...option,
+		type
+	});
+	return registry;
+};
+//#endregion
+//#region src/prefill/valuesFromSearchParams.ts
+const TRUTHY = new Set([
+	"true",
+	"1",
+	"on",
+	"yes"
+]);
+const coerce = (kind, raw, all) => {
+	switch (kind) {
+		case "number": {
+			const n = Number(raw);
+			return Number.isNaN(n) ? void 0 : n;
+		}
+		case "boolean": return TRUTHY.has(raw.toLowerCase());
+		case "text[]": return all;
+		default: return raw;
+	}
+};
+/**
+* Map URL/query params to typed initial values for KNOWN fields only, coerced by each field's value
+* kind. Unknown, denied, or un-allowed params are ignored; invalid numbers are dropped. Prefilled
+* values are never trusted -- they still validate on submit. Pass the result to `<Form initialValues>`.
+*/
+const valuesFromSearchParams = (params, fields, registry, options = {}) => {
+	const isSearch = params instanceof URLSearchParams;
+	const paramKeys = isSearch ? [...new Set(params.keys())] : Object.keys(params);
+	const byName = new Map(fields.map((field) => [field.name, field]));
+	const result = {};
+	for (const param of paramKeys) {
+		const fieldName = options.map?.[param] ?? param;
+		if (options.allow && !options.allow.includes(fieldName)) continue;
+		if (options.deny?.includes(fieldName)) continue;
+		const field = byName.get(fieldName);
+		const definition = field && registry.get(field.blockType);
+		if (!field || !definition) continue;
+		const all = isSearch ? params.getAll(param) : [params[param]];
+		const value = coerce(definition.value, all[0] ?? "", all);
+		if (value !== void 0) result[fieldName] = value;
+	}
+	return result;
+};
+//#endregion
+//#region src/recall/resolver.ts
+/** Derive a value->label map from a select-like field instance's `options`. */
+const optionLabelsFor = (field) => {
+	const options = field.options;
+	if (!Array.isArray(options)) return;
+	const map = {};
+	for (const option of options) if (option && typeof option.value === "string") map[option.value] = option.label ?? option.value;
+	return Object.keys(map).length > 0 ? map : void 0;
+};
+/**
+* Build a recall resolver: `{{name}}` -> the field's current value, formatted via its type's `format`
+* (so a select shows its option label, a checkbox Yes/No, a date localized). Missing field or empty
+* value -> ''. Pure and isomorphic; the renderer and server templates share it.
+*/
+const buildRecallResolver = (args) => {
+	const byName = new Map(args.fields.map((field) => [field.name, field]));
+	return (name) => {
+		const field = byName.get(name);
+		if (!field) return "";
+		const value = args.values[name];
+		if (value == null || value === "" || Array.isArray(value) && value.length === 0) return "";
+		const definition = args.registry.get(field.blockType);
+		if (definition?.format) return definition.format({
+			value,
+			config: {},
+			optionLabels: optionLabelsFor(field),
+			locale: args.locale,
+			t: args.t
+		});
+		return Array.isArray(value) ? value.join(", ") : String(value);
+	};
+};
+//#endregion
+export { IDENTITY_CONTEXT_KEY as _, resolveValidationRules as a, runValidation as c, computeCalcFields as d, evaluateCalc as f, DEFAULT_HONEYPOT_FIELD as g, CAPTCHA_TOKEN_KEY as h, buildRuleRegistry as i, evaluateCondition as l, defaultPresentationDescriptors as m, optionLabelsFor as n, defaultValidationRules as o, DEFAULT_PRESENTATION_NAME as p, valuesFromSearchParams as r, defineValidationRule as s, buildRecallResolver as t, calcExpressionOf as u, noopEventSink as v, interpolate as y };
+
+//# sourceMappingURL=resolver-OeQyVH2N.js.map