@verbb/formie-browser 1.0.0

package/dist/chunks/calculations-CkYAqO_-.js

@@ -0,0 +1,197 @@
+import { t as createDebug } from "./debug-KnZeKYBI.js";
+import { r as normalizeFieldKey, t as fieldKeyToInputName } from "./field-references.keys-BpBZ_quS.js";
+import { n as resolveFieldReferenceLive, r as buildFieldValueRegistry } from "./field-references.resolver-Ba6xhiJC.js";
+import { c as we, i as Te, n as K, s as q, t as Ce } from "./dist-D09GnXMW.js";
+import { r as getModuleFieldContainers, t as dispatchFieldEvent } from "./shared-DC6_1u8X.js";
+//#region src/js/modules/fields/calculations.ts
+var INPUT_SELECTOR = "input[data-formie-calculation-input]";
+var MODULE_ID = "calculations";
+var debug = createDebug("fields", "calculations");
+function resolveVariables(root, variableEntries, options) {
+	const registry = buildFieldValueRegistry(root);
+	const variables = {};
+	variableEntries.forEach(([variableKey, variable]) => {
+		variables[variableKey] = K(variable, resolveFieldReferenceLive(variable.sourceKey || "", registry).value);
+	});
+	return Te(variables, options.formatting);
+}
+function getWatchNames(root, variableEntries) {
+	const registry = buildFieldValueRegistry(root);
+	const watchNames = /* @__PURE__ */ new Set();
+	variableEntries.forEach(([, variable]) => {
+		const key = normalizeFieldKey(variable.sourceKey || "");
+		const entry = registry.get(key);
+		if (entry?.names?.length) {
+			entry.names.forEach((name) => {
+				watchNames.add(name);
+			});
+			return;
+		}
+		const fallback = fieldKeyToInputName(key);
+		if (fallback) {
+			watchNames.add(fallback);
+			watchNames.add(`${fallback}[]`);
+		}
+	});
+	return watchNames;
+}
+function bindCalculationsField(root, field, input, options) {
+	const formula = Ce(options);
+	const variableEntries = we(options);
+	const sourceBindings = /* @__PURE__ */ new Map();
+	let observer = null;
+	let destroyed = false;
+	let evaluateQueued = false;
+	let rebindQueued = false;
+	const cleanupBindings = () => {
+		sourceBindings.forEach((listeners, target) => {
+			listeners.forEach((listener, eventName) => {
+				target.removeEventListener(eventName, listener);
+			});
+		});
+		sourceBindings.clear();
+	};
+	const dispatchCalculatedValueChanged = (valueChanged) => {
+		if (!valueChanged || destroyed) return;
+		queueMicrotask(() => {
+			if (destroyed) return;
+			input.dispatchEvent(new Event("input", { bubbles: true }));
+			input.dispatchEvent(new Event("change", { bubbles: true }));
+		});
+	};
+	const evaluate = (isInit = false) => {
+		const variables = resolveVariables(root, variableEntries, options);
+		debug.log("Evaluate requested.", {
+			fieldHandle: field.getAttribute("data-formie-field-handle") || null,
+			isInit
+		});
+		const beforeDetail = {
+			calculations: input,
+			init: isInit,
+			formula,
+			variables
+		};
+		dispatchFieldEvent(field, MODULE_ID, "before-evaluate", beforeDetail);
+		if (!beforeDetail.formula) {
+			const valueChanged = input.value !== "";
+			input.value = "";
+			dispatchCalculatedValueChanged(valueChanged);
+			return;
+		}
+		try {
+			const result = q(beforeDetail.formula, beforeDetail.variables, options);
+			const afterDetail = {
+				calculations: input,
+				init: isInit,
+				formula: beforeDetail.formula,
+				variables: beforeDetail.variables,
+				result
+			};
+			dispatchFieldEvent(field, MODULE_ID, "after-evaluate", afterDetail);
+			const nextValue = typeof afterDetail.result === "string" || typeof afterDetail.result === "number" ? String(afterDetail.result) : "";
+			const valueChanged = input.value !== nextValue;
+			input.value = nextValue;
+			debug.log("Evaluate complete.", {
+				fieldHandle: field.getAttribute("data-formie-field-handle") || null,
+				valueChanged,
+				nextValue
+			});
+			dispatchCalculatedValueChanged(valueChanged);
+		} catch (error) {
+			const valueChanged = input.value !== "";
+			console.error("[formie] Failed to evaluate calculation.", error);
+			debug.warn("Evaluate failed.", {
+				fieldHandle: field.getAttribute("data-formie-field-handle") || null,
+				error: error instanceof Error ? error.message : error
+			});
+			input.value = "";
+			dispatchCalculatedValueChanged(valueChanged);
+		}
+	};
+	const scheduleEvaluate = (isInit = false) => {
+		if (evaluateQueued || destroyed) return;
+		evaluateQueued = true;
+		queueMicrotask(() => {
+			evaluateQueued = false;
+			evaluate(isInit);
+		});
+	};
+	const bindSources = () => {
+		cleanupBindings();
+		const watchNames = getWatchNames(root, variableEntries);
+		debug.log("Binding variable watchers.", {
+			fieldHandle: field.getAttribute("data-formie-field-handle") || null,
+			watchCount: watchNames.size
+		});
+		if (!watchNames.size) return;
+		const listener = (event) => {
+			const name = event.target?.name || "";
+			if (!name || !watchNames.has(name)) return;
+			debug.log("Source change detected.", {
+				fieldHandle: field.getAttribute("data-formie-field-handle") || null,
+				sourceName: name,
+				eventType: event.type
+			});
+			scheduleEvaluate(false);
+		};
+		["input", "change"].forEach((eventName) => {
+			root.addEventListener(eventName, listener);
+			const listeners = sourceBindings.get(root) || /* @__PURE__ */ new Map();
+			listeners.set(eventName, listener);
+			sourceBindings.set(root, listeners);
+		});
+	};
+	const scheduleRebind = () => {
+		if (rebindQueued || destroyed) return;
+		rebindQueued = true;
+		queueMicrotask(() => {
+			rebindQueued = false;
+			bindSources();
+			scheduleEvaluate(false);
+		});
+	};
+	bindSources();
+	observer = new MutationObserver(() => {
+		scheduleRebind();
+	});
+	observer.observe(root, {
+		childList: true,
+		subtree: true
+	});
+	evaluate(true);
+	return () => {
+		destroyed = true;
+		observer?.disconnect();
+		cleanupBindings();
+	};
+}
+var calculationsModule = {
+	id: MODULE_ID,
+	kind: "field",
+	match: (ctx) => {
+		return !!ctx.target.querySelector(INPUT_SELECTOR);
+	},
+	setup: async (ctx) => {
+		const options = ctx.options || {};
+		const fields = getModuleFieldContainers(ctx);
+		debug.log("Module setup.", {
+			fieldCount: fields.length,
+			formatting: options.formatting || null
+		});
+		const cleanups = fields.map((field) => {
+			const input = field.querySelector(INPUT_SELECTOR);
+			if (!(input instanceof HTMLInputElement)) return () => {};
+			return bindCalculationsField(ctx.root, field, input, options);
+		});
+		await ctx.emit("formie:module:calculations:init", { count: cleanups.length });
+		return { destroy: () => {
+			debug.log("Module destroy.", { fieldCount: cleanups.length });
+			cleanups.forEach((cleanup) => {
+				cleanup();
+			});
+			ctx.emit("formie:module:calculations:destroy", {});
+		} };
+	}
+};
+//#endregion
+export { calculationsModule };

package/dist/chunks/captcha-eu-DnOWhMwr.js

@@ -0,0 +1,43 @@
+import { a as CAPTCHA_PROVIDER_LOAD_TIMEOUT_MS, t as defineCaptchaModule } from "./api-DOfDzYC_.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/captchas/captcha-eu.ts
+async function loadCaptchaEuGlobal(options) {
+	return loadScriptAndEnsureGlobal("KROT", {
+		id: "FORMIE_CAPTCHA_EU_SCRIPT",
+		src: `${String(options.endPoint || "https://www.captcha.eu").trim().replace(/\/+$/, "")}/sdk.js`,
+		async: true,
+		defer: true,
+		timeoutMs: CAPTCHA_PROVIDER_LOAD_TIMEOUT_MS
+	});
+}
+var captchaEuModule = defineCaptchaModule({
+	id: "captcha-eu",
+	defaultPlaceholderSelector: "[data-captcha-eu-placeholder]",
+	defaultTokenFieldNames: ["captcha-eu-token"],
+	load: ({ options }) => {
+		return loadCaptchaEuGlobal(options.provider);
+	},
+	mount: ({ api, container, provider, services }) => {
+		api.init();
+		api.setup(String(provider.publicKey || ""));
+		api.WidgetV2.render(container);
+		api.on("CPT_OK", (event) => {
+			services.tokens.write(JSON.stringify(event.detail || {}), { container });
+			services.errors.clear();
+		}, container);
+		api.on("CPT_EXPIRED", () => {
+			services.tokens.clear();
+			services.errors.clear();
+		}, container);
+		return container;
+	},
+	screen: async ({ placeholder, services, stageCtx }) => {
+		if (!await services.tokens.wait()) {
+			const message = services.errors.getDefaultMessage();
+			services.errors.show(message, placeholder);
+			stageCtx.abort(message);
+		}
+	}
+});
+//#endregion
+export { captchaEuModule };

package/dist/chunks/checkbox-radio-0x7Tc0br.js

@@ -0,0 +1,197 @@
+import { t as createDebug } from "./debug-KnZeKYBI.js";
+import { c as retainFormValidators, n as escapeSelectorValue, s as releaseFormValidators, t as dispatchFieldEvent } from "./shared-DC6_1u8X.js";
+//#region src/js/modules/fields/checkbox-radio.ts
+var FIELD_SELECTOR = "[data-formie-checkboxes-field-layout], [data-formie-radio-field-layout]";
+var CHECKBOX_MINMAX_VALIDATOR = "minmaxOptions";
+var MAX_DISABLED_ATTR = "data-formie-checkbox-radio-max-disabled";
+var MODULE_ID = "checkbox-radio";
+var VALIDATOR_SCOPE = "checkbox-radio";
+var debug = createDebug("fields", "checkbox-radio");
+function isToggleCheckbox(input) {
+	return input.hasAttribute("data-checkbox-toggle") || input.hasAttribute("data-formie-checkbox-toggle");
+}
+function getMinMaxRule(getRule) {
+	const rule = getRule(CHECKBOX_MINMAX_VALIDATOR);
+	if (!rule || rule === true || typeof rule !== "object") return {
+		min: null,
+		max: null
+	};
+	const candidate = rule;
+	return {
+		min: typeof candidate.min === "number" ? candidate.min : null,
+		max: typeof candidate.max === "number" ? candidate.max : null
+	};
+}
+function registerValidators(form) {
+	retainFormValidators(form, VALIDATOR_SCOPE, (validator) => {
+		validator.addValidator(CHECKBOX_MINMAX_VALIDATOR, ({ field, getRule }) => {
+			if (!field || !getRule(CHECKBOX_MINMAX_VALIDATOR)) return true;
+			const selected = Array.from(field.querySelectorAll("input[type=\"checkbox\"]")).filter((input) => {
+				return input instanceof HTMLInputElement && !isToggleCheckbox(input);
+			}).filter((input) => {
+				return input.checked;
+			}).length;
+			const { min, max } = getMinMaxRule(getRule);
+			if (min !== null && selected < min) return false;
+			if (max !== null && selected > max) return false;
+			return true;
+		}, ({ field, label, t, getRule }) => {
+			const { min, max } = field ? getMinMaxRule(getRule) : {
+				min: null,
+				max: null
+			};
+			if (min !== null && max !== null) return t("{attribute} must select between {min} and {max}.", {
+				attribute: label,
+				min,
+				max
+			});
+			if (min !== null) return t("{attribute} must select no less than {min}.", {
+				attribute: label,
+				min
+			});
+			if (max !== null) return t("{attribute} must select no greater than {max}.", {
+				attribute: label,
+				max
+			});
+			return t("{attribute} has an invalid value.", { attribute: label });
+		});
+	});
+}
+function unregisterValidators(form) {
+	releaseFormValidators(form, VALIDATOR_SCOPE, [CHECKBOX_MINMAX_VALIDATOR]);
+}
+function syncCheckedAttribute(input) {
+	if (input.checked) input.setAttribute("checked", "");
+	else input.removeAttribute("checked");
+}
+function syncRequiredCheckboxes(field) {
+	const requiredCheckboxes = Array.from(field.querySelectorAll("input[type=\"checkbox\"][required][data-formie-checkbox-input]")).filter((input) => {
+		return input instanceof HTMLInputElement;
+	});
+	if (!requiredCheckboxes.length) return;
+	const hasCheckedValue = requiredCheckboxes.some((input) => {
+		return input.checked;
+	});
+	requiredCheckboxes.forEach((input) => {
+		if (hasCheckedValue) {
+			input.removeAttribute("required");
+			input.setAttribute("aria-required", "false");
+			return;
+		}
+		input.setAttribute("required", "true");
+		input.setAttribute("aria-required", "true");
+	});
+}
+function enforceMaxOptions(field) {
+	const maxOptions = parseInt(field.closest("[data-formie-field-handle]")?.getAttribute("data-formie-max-options") || "", 10);
+	if (!(maxOptions > 0)) return;
+	const checkboxes = Array.from(field.querySelectorAll("input[type=\"checkbox\"]")).filter((input) => {
+		return input instanceof HTMLInputElement && !isToggleCheckbox(input);
+	});
+	const disableUnchecked = checkboxes.filter((input) => {
+		return input.checked;
+	}).length >= maxOptions;
+	checkboxes.forEach((input) => {
+		const shouldDisableForMax = disableUnchecked && !input.checked;
+		const wasDisabledForMax = input.hasAttribute(MAX_DISABLED_ATTR);
+		if (shouldDisableForMax) {
+			if (!input.disabled) {
+				input.disabled = true;
+				input.setAttribute(MAX_DISABLED_ATTR, "true");
+			}
+			return;
+		}
+		if (wasDisabledForMax) {
+			input.disabled = false;
+			input.removeAttribute(MAX_DISABLED_ATTR);
+		}
+	});
+}
+function toggleCheckboxGroup(field, toggle) {
+	Array.from(field.querySelectorAll("input[type=\"checkbox\"]")).filter((input) => {
+		return input instanceof HTMLInputElement && input !== toggle && !isToggleCheckbox(input);
+	}).forEach((input) => {
+		if (input.disabled && !input.checked) return;
+		input.checked = toggle.checked;
+		syncCheckedAttribute(input);
+		input.dispatchEvent(new Event("change", { bubbles: true }));
+		input.dispatchEvent(new Event("input", { bubbles: true }));
+	});
+}
+function syncRadioGroup(input, field) {
+	if (!input.checked || !input.name) {
+		syncCheckedAttribute(input);
+		return;
+	}
+	Array.from(field.querySelectorAll(`input[type="radio"][name="${escapeSelectorValue(input.name)}"]`)).filter((radio) => {
+		return radio instanceof HTMLInputElement;
+	}).forEach((radio) => {
+		syncCheckedAttribute(radio);
+	});
+}
+function bindField(field) {
+	const inputs = Array.from(field.querySelectorAll("input[type=\"checkbox\"], input[type=\"radio\"]")).filter((input) => {
+		return input instanceof HTMLInputElement;
+	});
+	if (!inputs.length) {
+		debug.log("No checkbox/radio inputs found for field.");
+		return () => {};
+	}
+	const listeners = inputs.map((input) => {
+		const eventName = input.type === "radio" ? "change" : "click";
+		const handler = () => {
+			syncCheckedAttribute(input);
+			if (input.type === "checkbox" && isToggleCheckbox(input)) toggleCheckboxGroup(field, input);
+			if (input.type === "radio") syncRadioGroup(input, field);
+			syncRequiredCheckboxes(field);
+			enforceMaxOptions(field);
+			debug.log("Input interaction processed.", {
+				inputName: input.name,
+				inputType: input.type,
+				checked: input.checked
+			});
+		};
+		input.addEventListener(eventName, handler);
+		syncCheckedAttribute(input);
+		return () => {
+			input.removeEventListener(eventName, handler);
+		};
+	});
+	syncRequiredCheckboxes(field);
+	enforceMaxOptions(field);
+	dispatchFieldEvent(field, MODULE_ID, "init", { checkboxRadio: field });
+	return () => {
+		listeners.forEach((unbind) => {
+			unbind();
+		});
+	};
+}
+var checkboxRadioModule = {
+	id: MODULE_ID,
+	kind: "field",
+	match: (ctx) => {
+		return ctx.target instanceof HTMLElement && (ctx.target.matches(FIELD_SELECTOR) || !!ctx.target.querySelector(FIELD_SELECTOR));
+	},
+	setup: async (ctx) => {
+		if (!(ctx.target instanceof HTMLElement)) return;
+		const fields = ctx.target.matches(FIELD_SELECTOR) ? [ctx.target] : Array.from(ctx.target.querySelectorAll(FIELD_SELECTOR)).filter((field) => {
+			return field instanceof HTMLElement;
+		});
+		registerValidators(ctx.form);
+		debug.log("Module setup.", { fieldCount: fields.length });
+		const destroyBindings = fields.map((field) => {
+			return bindField(field);
+		});
+		await ctx.emit("formie:module:checkbox-radio:init", { count: fields.length });
+		return { destroy: () => {
+			destroyBindings.forEach((destroyBinding) => {
+				destroyBinding();
+			});
+			unregisterValidators(ctx.form);
+			debug.log("Module destroy.", { fieldCount: fields.length });
+			ctx.emit("formie:module:checkbox-radio:destroy", {});
+		} };
+	}
+};
+//#endregion
+export { checkboxRadioModule };

package/dist/chunks/chunk-K6L4z4UQ.js

@@ -0,0 +1,24 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+export { __toESM as n, __commonJSMin as t };