@verbb/formie-browser 1.0.0

package/dist/chunks/snaptcha-CCDunGeb.js

@@ -0,0 +1,8 @@
+import { n as definePassiveCaptchaModule } from "./api-DOfDzYC_.js";
+//#region src/js/modules/captchas/snaptcha.ts
+var snaptchaModule = definePassiveCaptchaModule({
+	id: "snaptcha",
+	defaultPlaceholderSelector: "[data-snaptcha-captcha-placeholder]"
+});
+//#endregion
+export { snaptchaModule };

package/dist/chunks/square-BLqK51rS.js

@@ -0,0 +1,61 @@
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/payments/square.ts
+var SCRIPT_ID = "FORMIE_SQUARE_SCRIPT";
+var squareModule = definePaymentModule({
+	id: "square",
+	defaultRequiredInputSuffixes: ["squarePaymentId"],
+	load: async (ctx) => {
+		const { provider } = ctx.options;
+		const applicationId = provider.applicationId;
+		const locationId = provider.locationId;
+		if (!applicationId?.trim() || !locationId?.trim()) {
+			console.error("[formie] Missing applicationId or locationId for Square.");
+			return null;
+		}
+		await loadScriptAndEnsureGlobal("Square", {
+			id: SCRIPT_ID,
+			src: provider.environment === "sandbox" ? "https://sandbox.web.squarecdn.com/v1/square.js" : "https://web.squarecdn.com/v1/square.js"
+		});
+		return window.Square;
+	},
+	mount: async (args) => {
+		const { api, field, services, options } = args;
+		const provider = options.provider;
+		const placeholder = field.querySelector("[data-formie-square-button]");
+		if (!placeholder || !api) return null;
+		try {
+			const card = await api.payments(provider.applicationId || "", provider.locationId || "").card();
+			await card.attach(placeholder);
+			return card;
+		} catch (error) {
+			services.addError(error instanceof Error ? error.message : "Unable to initialize payment.");
+			return null;
+		}
+	},
+	unmount: async () => {},
+	onBeforeAuthorize: async (args) => {
+		const { widget, services } = args;
+		if (!widget) {
+			services.addError("Square card is not ready.");
+			return false;
+		}
+		try {
+			const result = await widget.tokenize();
+			if (result.status === "OK" && result.token) {
+				services.updateInputs("squarePaymentId", result.token);
+				return true;
+			}
+			services.addError(result.errors?.[0]?.message || "Tokenization failed.");
+			return false;
+		} catch {
+			services.addError("Payment tokenization failed. Please try again.");
+			return false;
+		}
+	},
+	onAfterSubmit: async ({ services }) => {
+		services.updateInputs("squarePaymentId", "");
+	}
+});
+//#endregion
+export { squareModule };

package/dist/chunks/stripe-B8gHpZNC.js

@@ -0,0 +1,273 @@
+import { s as getPaymentProviderActionEventName } from "./event-names-DamGPtXR.js";
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+import { r as removeThemeClasses, t as addThemeClasses } from "./theme-classes-vSHpdCUO.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+import { t as ensureModuleStyles } from "./styles-BIh6g7V_.js";
+//#endregion
+//#region src/js/modules/payments/stripe.ts
+ensureModuleStyles("stripe", ["@layer formie-theme{.formie-stripe-placeholder{justify-content:center;align-items:center;gap:var(--formie-space-2);width:100%;min-height:12rem;padding:var(--formie-space-4);border:var(--formie-border-width) solid var(--formie-color-border);border-radius:var(--formie-radius-sm);background:var(--formie-color-surface);color:var(--formie-color-text-muted);text-align:center;box-sizing:border-box;flex-direction:column;display:flex}.formie-stripe-placeholder[hidden]{display:none}}"]);
+var SCRIPT_ID = "FORMIE_STRIPE_SCRIPT";
+var CONFIRM_EVENT = getPaymentProviderActionEventName("stripe", "confirm");
+var PLACEHOLDER_SELECTOR = "[data-formie-stripe-elements-placeholder]";
+var ZERO_DECIMAL_CURRENCIES = new Set([
+	"BIF",
+	"CLP",
+	"DJF",
+	"GNF",
+	"JPY",
+	"KMF",
+	"KRW",
+	"MGA",
+	"PYG",
+	"RWF",
+	"UGX",
+	"VND",
+	"VUV",
+	"XAF",
+	"XOF",
+	"XPF"
+]);
+function toStripeSubunitAmount(amount, currency) {
+	if (ZERO_DECIMAL_CURRENCIES.has(currency.toUpperCase())) return Math.ceil(amount);
+	return Math.ceil(amount * 100);
+}
+function clearPlaceholderError(placeholder, themeSource) {
+	if (!placeholder) return;
+	removeThemeClasses(placeholder, themeSource, "fieldErrors", "fieldError");
+	placeholder.querySelectorAll("[data-payment-placeholder-error]").forEach((el) => {
+		removeThemeClasses(el, themeSource, "fieldError");
+	});
+}
+function renderPlaceholderLoading(placeholder, themeSource, message = "Loading payment options...") {
+	if (!placeholder) return;
+	clearPlaceholderError(placeholder, themeSource);
+	placeholder.removeAttribute("hidden");
+	placeholder.innerHTML = "";
+	const spinner = document.createElement("div");
+	spinner.className = "formie-loading";
+	const text = document.createElement("div");
+	text.textContent = message;
+	placeholder.append(spinner, text);
+}
+function showPlaceholderMessage(placeholder, themeSource, message) {
+	if (!placeholder) return;
+	clearPlaceholderError(placeholder, themeSource);
+	placeholder.removeAttribute("hidden");
+	addThemeClasses(placeholder, themeSource, "fieldErrors");
+	placeholder.innerHTML = "";
+	const error = document.createElement("div");
+	error.setAttribute("data-payment-placeholder-error", "");
+	error.textContent = message;
+	addThemeClasses(error, themeSource, "fieldError");
+	placeholder.appendChild(error);
+}
+var stripeModule = definePaymentModule({
+	id: "stripe",
+	defaultRequiredInputSuffixes: ["stripePaymentIntentId"],
+	load: async (ctx) => {
+		const { provider } = ctx.options;
+		const publishableKey = provider.publishableKey;
+		if (!publishableKey?.trim()) {
+			console.error("[formie] Missing publishableKey for Stripe.");
+			return null;
+		}
+		return (await loadScriptAndEnsureGlobal("Stripe", {
+			id: SCRIPT_ID,
+			src: "https://js.stripe.com/v3"
+		}))(publishableKey);
+	},
+	mount: async (args) => {
+		const { api, field, services, provider } = args;
+		const placeholder = field.querySelector("[data-formie-stripe-elements]");
+		const loadingPlaceholder = field.querySelector(PLACEHOLDER_SELECTOR);
+		const stripeField = field;
+		const themeSource = services.form || services.root;
+		if (!placeholder || !api) return null;
+		const initial = provider.initialPaymentInformation || {};
+		const dynamicHandles = [initial.amount, initial.currency].map((value) => String(value ?? "").trim()).filter((value, index) => {
+			return (index === 0 ? provider.amountType : provider.currencyType) === "dynamic" && value !== "";
+		});
+		const getResolvedPaymentInfo = () => {
+			const amountResult = services.resolveAmount({ value: initial.amount });
+			if (!amountResult.ok) return {
+				ok: false,
+				error: "error" in amountResult ? amountResult.error : "Provide a payment amount to proceed."
+			};
+			const currencyResult = services.resolveCurrency({ value: initial.currency });
+			if (!currencyResult.ok) return {
+				ok: false,
+				error: "error" in currencyResult ? currencyResult.error : "Provide a payment currency to proceed."
+			};
+			const currencyCode = currencyResult.value.toLowerCase();
+			const amountValue = provider.amountType === "dynamic" ? toStripeSubunitAmount(amountResult.value, currencyCode) : amountResult.value;
+			return {
+				ok: true,
+				value: {
+					...initial,
+					capture_method: "automatic",
+					mode: provider.paymentType === "subscription" ? "subscription" : "payment",
+					appearance: {},
+					amount: amountValue,
+					currency: currencyCode
+				}
+			};
+		};
+		const destroyWidget = () => {
+			try {
+				stripeField.__formieStripeWidget?.paymentElement?.destroy?.();
+			} catch (error) {}
+			stripeField.__formieStripeWidget = null;
+			stripeField.__formieStripeElements = void 0;
+			placeholder.innerHTML = "";
+		};
+		const evaluateAndRender = () => {
+			const resolved = getResolvedPaymentInfo();
+			if (!resolved.ok) {
+				destroyWidget();
+				showPlaceholderMessage(loadingPlaceholder, themeSource, "error" in resolved ? resolved.error : "Unable to resolve payment details.");
+				return;
+			}
+			try {
+				if (stripeField.__formieStripeWidget && stripeField.__formieStripeElements) {
+					stripeField.__formieStripeElements.update(resolved.value);
+					clearPlaceholderError(loadingPlaceholder, themeSource);
+					loadingPlaceholder?.setAttribute("hidden", "hidden");
+					return;
+				}
+				renderPlaceholderLoading(loadingPlaceholder, themeSource);
+				const elements = api.elements(resolved.value);
+				const paymentElement = elements.create("payment", {});
+				paymentElement.mount(placeholder);
+				paymentElement.on?.("loaderror", (event) => {
+					const message = event?.error?.message || "Unable to load payment options.";
+					destroyWidget();
+					showPlaceholderMessage(loadingPlaceholder, themeSource, message);
+				});
+				paymentElement.on?.("ready", () => {
+					clearPlaceholderError(loadingPlaceholder, themeSource);
+					loadingPlaceholder?.setAttribute("hidden", "hidden");
+				});
+				stripeField.__formieStripeElements = elements;
+				stripeField.__formieStripeInstance = api;
+				stripeField.__formieStripeWidget = {
+					elements,
+					paymentElement
+				};
+				if (!paymentElement.on) {
+					clearPlaceholderError(loadingPlaceholder, themeSource);
+					loadingPlaceholder?.setAttribute("hidden", "hidden");
+				}
+			} catch (error) {
+				destroyWidget();
+				showPlaceholderMessage(loadingPlaceholder, themeSource, error instanceof Error ? error.message : "Unable to initialize Stripe payment element.");
+			}
+		};
+		stripeField.__formieStripeEvaluateAndRender = evaluateAndRender;
+		stripeField.__formieStripeDynamicUnbind?.();
+		if (dynamicHandles.length > 0) stripeField.__formieStripeDynamicUnbind = services.watchFieldValueChanges(dynamicHandles, () => {
+			evaluateAndRender();
+		}, 600);
+		evaluateAndRender();
+		return stripeField.__formieStripeWidget || null;
+	},
+	unmount: async (args) => {
+		args.widget?.paymentElement?.destroy();
+		const stripeField = args.field;
+		stripeField.__formieStripeWidget = null;
+		stripeField.__formieStripeElements = void 0;
+		stripeField.__formieStripeInstance = null;
+		stripeField.__formieStripeLastClientSecret = void 0;
+		stripeField.__formieStripeEvaluateAndRender = null;
+		stripeField.__formieStripeDynamicUnbind?.();
+		stripeField.__formieStripeDynamicUnbind = null;
+	},
+	onBeforeAuthorize: async (args) => {
+		const { widget, services, field } = args;
+		const stripeField = field;
+		let activeWidget = widget;
+		if (!activeWidget?.elements) {
+			stripeField.__formieStripeEvaluateAndRender?.();
+			activeWidget = stripeField.__formieStripeWidget || null;
+		}
+		if (!activeWidget?.elements) return false;
+		const result = await activeWidget.elements.submit();
+		if (result?.error) {
+			services.addError(result.error.message);
+			return false;
+		}
+		return true;
+	},
+	setup: async (ctx) => {
+		const { services, options } = ctx;
+		const provider = options.provider;
+		const field = ctx.target;
+		const handler = async (event) => {
+			try {
+				const data = event.detail?.data;
+				if (!data?.clientSecret) return;
+				if (field.__formieStripeConfirming) return;
+				if (field.__formieStripeLastClientSecret === data.clientSecret) return;
+				const elements = field.__formieStripeElements;
+				if (!elements) {
+					services.addError("Stripe elements not ready for 3DS.");
+					return;
+				}
+				const instance = field.__formieStripeInstance;
+				const publishableKey = provider.publishableKey;
+				if (!instance || !publishableKey) {
+					services.addError("Stripe is not initialized.");
+					return;
+				}
+				field.__formieStripeConfirming = true;
+				const returnUrl = new URL(data.returnUrl || window.location.href);
+				returnUrl.searchParams.set("origin", window.location.href);
+				const result = await (data.type === "setup" ? instance.confirmSetup : instance.confirmPayment)({
+					elements,
+					clientSecret: data.clientSecret,
+					redirect: "if_required",
+					confirmParams: { return_url: returnUrl.toString() }
+				});
+				if (result?.error) {
+					services.releaseSubmitLoading();
+					services.addError(result.error.message);
+					return;
+				}
+				if (data.subscriptionId) services.updateInputs("stripeSubscriptionId", data.subscriptionId);
+				const pi = result && "paymentIntent" in result ? result.paymentIntent : null;
+				const si = result && "setupIntent" in result ? result.setupIntent : null;
+				if (pi?.id) services.updateInputs("stripePaymentIntentId", pi.id);
+				else if (si?.id) services.updateInputs("stripePaymentIntentId", si.id);
+				else {
+					services.releaseSubmitLoading();
+					services.addError("Stripe confirmation did not return an intent ID.");
+					return;
+				}
+				field.__formieStripeLastClientSecret = data.clientSecret;
+				services.triggerSubmit();
+			} catch (error) {
+				services.releaseSubmitLoading();
+				services.addError(error instanceof Error ? error.message : "Unable to confirm Stripe payment.");
+			} finally {
+				field.__formieStripeConfirming = false;
+			}
+		};
+		field.__formieStripeConfirmUnbind?.();
+		field.__formieStripeConfirmUnbind = services.events.onForm(CONFIRM_EVENT, handler);
+		return { destroy: () => {
+			field.__formieStripeConfirmUnbind?.();
+			field.__formieStripeConfirmUnbind = null;
+		} };
+	},
+	onAfterSubmit: async (args) => {
+		const stripeField = args.field;
+		if (args.result?.ok && !args.result?.nextPage) {
+			stripeField.__formieStripeWidget?.paymentElement?.destroy?.();
+			stripeField.__formieStripeWidget = null;
+			stripeField.__formieStripeElements = void 0;
+			args.services.updateInputs(["stripePaymentIntentId", "stripeSubscriptionId"], "");
+			stripeField.__formieStripeLastClientSecret = void 0;
+		}
+	}
+});
+//#endregion
+export { stripeModule };

package/dist/chunks/styles-BIh6g7V_.js

@@ -0,0 +1,22 @@
+//#region src/js/modules/styles.ts
+var injectedModuleStyles = /* @__PURE__ */ new Set();
+function ensureModuleStyles(moduleId, styles) {
+	if (typeof document === "undefined") return;
+	const styleId = `formie-module-style:${moduleId}`;
+	if (injectedModuleStyles.has(styleId) || document.querySelector(`style[data-formie-module-style="${moduleId}"]`)) {
+		injectedModuleStyles.add(styleId);
+		return;
+	}
+	const cssText = styles.filter((style) => typeof style === "string" && style.trim().length > 0).join("\n");
+	if (!cssText) {
+		injectedModuleStyles.add(styleId);
+		return;
+	}
+	const style = document.createElement("style");
+	style.setAttribute("data-formie-module-style", moduleId);
+	style.textContent = cssText;
+	document.head.appendChild(style);
+	injectedModuleStyles.add(styleId);
+}
+//#endregion
+export { ensureModuleStyles as t };

package/dist/chunks/summary-EcNE0cvg.js

@@ -0,0 +1,191 @@
+import { t as createDebug } from "./debug-KnZeKYBI.js";
+import { i as toggleThemeClasses } from "./theme-classes-vSHpdCUO.js";
+import { n as requestText } from "./http-18nn97DZ.js";
+import { t as debounce } from "./async-B3DUf1GZ.js";
+import { t as ensureModuleStyles } from "./styles-BIh6g7V_.js";
+import { r as getModuleFieldContainers, t as dispatchFieldEvent } from "./shared-DC6_1u8X.js";
+//#region src/css/theme/fields/_summary.css?inline
+var _summary_default = "@layer formie-theme{.formie-summary-container{padding:var(--formie-summary-padding);border:var(--formie-border-width) solid var(--formie-color-border);border-radius:var(--formie-radius-sm)}.formie-summary-heading{color:var(--formie-color-heading)}.formie-summary-blocks{gap:var(--formie-gap-summary);display:grid}.formie-summary-blocks[data-formie-loading=true]{min-height:calc(var(--formie-loading-size) + var(--formie-space-4));position:relative}.formie-summary-blocks[data-formie-loading=true]>*{opacity:0;pointer-events:none}.formie-summary-blocks[data-formie-loading=true]:before{content:\"\";background:var(--formie-color-bg);border-radius:inherit;z-index:1;display:block;position:absolute;inset:0}.formie-summary-blocks[data-formie-loading=true]:after{width:var(--formie-loading-size);height:var(--formie-loading-size);content:\"\";border:var(--formie-loading-border-width) solid var(--formie-loading-color);border-radius:var(--formie-radius-full);z-index:2;animation:formie-loading-spin var(--formie-loading-speed) linear infinite;border-top-color:#0000;border-right-color:#0000;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}}";
+//#endregion
+//#region src/js/modules/fields/summary.ts
+var BLOCKS_SELECTOR = "[data-formie-summary-blocks]";
+var CONTAINER_SELECTOR = "[data-formie-summary-container]";
+var SUMMARY_ACTION = "formie/fields/get-summary-html";
+var MODULE_ID = "summary";
+var debug = createDebug("fields", "summary");
+ensureModuleStyles(MODULE_ID, [_summary_default]);
+function getSummaryRequestUrl() {
+	const url = new URL(window.location.href);
+	url.hash = "";
+	return url.toString();
+}
+function getSummaryRequestState(field) {
+	return { accessToken: field.querySelector("[data-formie-summary-token]")?.value?.trim() || null };
+}
+async function requestSummaryHtml(form, state, signal) {
+	if (!state.accessToken) throw new Error("Summary field requires an access token.");
+	const formData = new FormData(form);
+	formData.set("action", SUMMARY_ACTION);
+	formData.set("accessToken", state.accessToken);
+	return requestText(getSummaryRequestUrl(), {
+		method: "POST",
+		body: formData,
+		signal,
+		headers: { Accept: "text/html" }
+	});
+}
+function initSummaryField(field, root) {
+	const form = field.closest("form");
+	if (!(form instanceof HTMLFormElement)) {
+		debug.warn("Missing form ancestor; skipping field.");
+		return () => {};
+	}
+	let hasFetched = false;
+	let isDirty = true;
+	let isVisible = false;
+	let dirtyVersion = 0;
+	let requestVersion = 0;
+	let activeRequest = null;
+	const getBlocks = () => {
+		const blocks = field.querySelector(BLOCKS_SELECTOR);
+		return blocks instanceof HTMLElement ? blocks : null;
+	};
+	const getContainer = () => {
+		const container = field.querySelector(CONTAINER_SELECTOR);
+		return container instanceof HTMLElement ? container : null;
+	};
+	const setLoadingState = (isLoading) => {
+		const blocks = getBlocks();
+		if (!blocks) return;
+		if (isLoading) {
+			blocks.setAttribute("data-formie-loading", "true");
+			blocks.setAttribute("aria-busy", "true");
+			toggleThemeClasses(blocks, form, "loading", true);
+			return;
+		}
+		blocks.removeAttribute("data-formie-loading");
+		blocks.removeAttribute("aria-busy");
+		toggleThemeClasses(blocks, form, "loading", false);
+	};
+	setLoadingState(!!getSummaryRequestState(field).accessToken);
+	const queueFetch = () => {
+		if (!isVisible || hasFetched && !isDirty) return;
+		debug.log("Queueing fetch.");
+		fetchSummary();
+	};
+	const fetchSummary = debounce(async () => {
+		const state = getSummaryRequestState(field);
+		if (!getBlocks() || !state.accessToken) {
+			debug.warn("Missing state for fetch.", state);
+			setLoadingState(false);
+			return;
+		}
+		requestVersion += 1;
+		const currentRequestVersion = requestVersion;
+		const requestDirtyVersion = dirtyVersion;
+		activeRequest?.abort();
+		activeRequest = new AbortController();
+		setLoadingState(true);
+		try {
+			const html = await requestSummaryHtml(form, state, activeRequest.signal);
+			if (currentRequestVersion !== requestVersion) return;
+			const container = getContainer();
+			const nextMarkup = document.createElement("template");
+			nextMarkup.innerHTML = html.trim();
+			const nextContainer = nextMarkup.content.querySelector(CONTAINER_SELECTOR);
+			if (container && nextContainer instanceof HTMLElement) container.replaceWith(nextContainer);
+			else if (container) container.innerHTML = html;
+			hasFetched = true;
+			isDirty = dirtyVersion !== requestDirtyVersion;
+			debug.log("Fetch complete.", {
+				isDirty,
+				dirtyVersion,
+				requestVersion: currentRequestVersion
+			});
+			dispatchFieldEvent(field, MODULE_ID, "fetch-summary", {
+				summary: field,
+				html
+			});
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") {
+				debug.log("Fetch aborted.");
+				return;
+			}
+			console.error("[formie] Failed to load summary field HTML.", error);
+		} finally {
+			if (currentRequestVersion === requestVersion) {
+				setLoadingState(false);
+				activeRequest = null;
+				if (isDirty) queueFetch();
+			}
+		}
+	}, 300);
+	const markDirty = (event) => {
+		const target = event?.target;
+		if (target instanceof Node && field.contains(target)) return;
+		isDirty = true;
+		dirtyVersion += 1;
+		debug.log("Marked dirty.", { dirtyVersion });
+	};
+	const handleFieldMutation = (event) => {
+		markDirty(event);
+		queueFetch();
+	};
+	const handleSubmitResult = () => {
+		isDirty = true;
+		debug.log("Submit result received; refreshing.");
+		queueFetch();
+	};
+	const handlePageNavigate = () => {
+		isDirty = true;
+		debug.log("Page navigation received; refreshing.");
+		queueFetch();
+	};
+	const observer = new IntersectionObserver((entries) => {
+		isVisible = !!entries[0]?.isIntersecting;
+		if (!isVisible) return;
+		debug.log("Field became visible.");
+		dispatchFieldEvent(field, MODULE_ID, "field-visible", { summary: field });
+		queueFetch();
+	}, {
+		root: form,
+		rootMargin: "50px"
+	});
+	observer.observe(field);
+	form.addEventListener("input", handleFieldMutation);
+	form.addEventListener("change", handleFieldMutation);
+	root.addEventListener("formie:page:navigate:after", handlePageNavigate);
+	root.addEventListener("formie:submit:result", handleSubmitResult);
+	return () => {
+		activeRequest?.abort();
+		observer.disconnect();
+		form.removeEventListener("input", handleFieldMutation);
+		form.removeEventListener("change", handleFieldMutation);
+		root.removeEventListener("formie:page:navigate:after", handlePageNavigate);
+		root.removeEventListener("formie:submit:result", handleSubmitResult);
+		debug.log("Field destroyed.");
+	};
+}
+var summaryModule = {
+	id: MODULE_ID,
+	kind: "field",
+	match: (ctx) => {
+		return !!ctx.target.querySelector(BLOCKS_SELECTOR);
+	},
+	setup: async (ctx) => {
+		const cleanups = getModuleFieldContainers(ctx).map((field) => {
+			return initSummaryField(field, ctx.root);
+		});
+		debug.log("Module setup.", { fieldCount: cleanups.length });
+		await ctx.emit("formie:module:summary:init", { count: cleanups.length });
+		return { destroy: () => {
+			cleanups.forEach((cleanup) => {
+				cleanup();
+			});
+			debug.log("Module destroy.", { fieldCount: cleanups.length });
+			ctx.emit("formie:module:summary:destroy", {});
+		} };
+	}
+};
+//#endregion
+export { summaryModule };

package/dist/chunks/table-yxEDL6kA.js

@@ -0,0 +1,124 @@
+import { n as sleep } from "./async-B3DUf1GZ.js";
+import { t as ensureModuleStyles } from "./styles-BIh6g7V_.js";
+import { a as getTemplateSource, o as getTemplateSourceHtml, t as dispatchFieldEvent } from "./shared-DC6_1u8X.js";
+//#region src/css/theme/fields/_table.css?inline
+var _table_default = "@layer formie-theme{.formie-table-wrapper{-webkit-overflow-scrolling:touch;max-width:100%;overflow:auto hidden}.formie-table{width:var(--formie-table-width);margin-bottom:var(--formie-table-margin-bottom);border-collapse:var(--formie-table-border-collapse)}.formie-table th{text-align:var(--formie-table-th-text-align);font-size:var(--formie-table-th-font-size);font-weight:var(--formie-table-th-font-weight);color:var(--formie-table-th-color,var(--formie-gray-500))}.formie-table th,.formie-table td{padding:var(--formie-table-row-padding);vertical-align:top}.formie-table th:first-child,.formie-table td:first-child{padding-left:0}.formie-table th:last-child,.formie-table td:last-child{padding-right:0}.formie-table [data-col-remove]{width:calc(var(--formie-button-icon-button-size) + (var(--formie-table-row-padding) * 2));min-width:calc(var(--formie-button-icon-button-size) + (var(--formie-table-row-padding) * 2));white-space:nowrap;text-align:center;vertical-align:middle}.formie-table [data-formie-table-column-type=checkbox]{text-align:center;vertical-align:middle}.formie-table [data-formie-table-column-type=checkbox] .formie-checkbox-option{width:100%;min-height:var(--formie-check-size);justify-content:center;align-items:center;margin:0;display:flex}.formie-table [data-formie-table-column-type=checkbox] .formie-checkbox-option-label{width:var(--formie-check-size);min-width:var(--formie-check-size);height:var(--formie-check-size);margin:0 auto;padding-left:0;font-size:0;line-height:0;display:block}.formie-table [data-formie-table-column-type=checkbox] .formie-checkbox-option-label:before{position:static}.formie-table-color-input{min-width:4rem;padding:var(--formie-space-1)}.formie-table-multiline-input{min-height:calc(var(--formie-control-height) + var(--formie-space-2))}.formie-table-remove-button{vertical-align:middle;display:inline-flex}.formie-button.formie-table-add-button{width:auto;max-width:100%;padding-left:var(--formie-table-add-button-padding-left);justify-content:center;justify-self:start;align-items:center;display:inline-flex;position:relative}.formie-button.formie-table-add-button:before{content:\"\";width:var(--formie-table-add-button-width);height:var(--formie-table-add-button-height);left:var(--formie-table-add-button-left);-webkit-mask-image:var(--formie-table-add-button-icon-mask);-webkit-mask-image:var(--formie-table-add-button-icon-mask);mask-image:var(--formie-table-add-button-icon-mask);background-color:currentColor;display:block;position:absolute;top:50%;transform:translateY(-50%);-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:contain;mask-size:contain;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}}";
+//#endregion
+//#region src/js/modules/fields/table.ts
+var FIELD_SELECTOR = "[data-formie-table-field-layout]";
+var TABLE_SELECTOR = "[data-formie-table]";
+var TABLE_BODY_SELECTOR = "[data-formie-table-body]";
+var ROW_SELECTOR = "[data-formie-table-row]";
+var ADD_SELECTOR = "[data-formie-table-add]";
+var REMOVE_SELECTOR = "[data-formie-table-remove]";
+var TEMPLATE_ID_ATTR = "data-formie-template-id";
+var ROW_ID_ATTR = "data-formie-table-row-id";
+var MODULE_ID = "table";
+ensureModuleStyles(MODULE_ID, [_table_default]);
+function getTemplate(field, templateId) {
+	return getTemplateSource(field, templateId);
+}
+function getRowCount(field) {
+	return field.querySelectorAll(ROW_SELECTOR).length;
+}
+function getNextRowId(field) {
+	return Array.from(field.querySelectorAll(ROW_SELECTOR)).reduce((max, row) => {
+		const current = parseInt(row.getAttribute(ROW_ID_ATTR) || "", 10);
+		return Number.isNaN(current) ? max : Math.max(max, current + 1);
+	}, 0);
+}
+function syncAddButton(addButton, rowCount) {
+	if (!addButton) return;
+	const maxRows = parseInt(addButton.getAttribute("data-formie-max-rows") || "", 10);
+	addButton.disabled = maxRows > 0 && rowCount >= maxRows;
+}
+function bindTableField(field, options) {
+	const table = field.querySelector(TABLE_SELECTOR);
+	const tbody = field.querySelector(TABLE_BODY_SELECTOR);
+	const addButton = field.querySelector(ADD_SELECTOR);
+	if (!(table instanceof HTMLElement) || !(tbody instanceof HTMLElement)) return () => {};
+	const removeHandlers = /* @__PURE__ */ new Map();
+	let rowCounter = getNextRowId(field);
+	const bindRemoveButtons = () => {
+		field.querySelectorAll(REMOVE_SELECTOR).forEach((button) => {
+			if (!(button instanceof HTMLElement) || removeHandlers.has(button)) return;
+			const handler = (event) => {
+				event.preventDefault();
+				const row = button.closest(ROW_SELECTOR);
+				if (!(row instanceof HTMLElement)) return;
+				const minRows = parseInt((addButton instanceof HTMLButtonElement ? addButton.getAttribute("data-formie-min-rows") : "") || "", 10);
+				if (minRows > 0 && getRowCount(field) <= minRows) return;
+				row.remove();
+				syncAddButton(addButton instanceof HTMLButtonElement ? addButton : null, getRowCount(field));
+				dispatchFieldEvent(field, MODULE_ID, "remove", {
+					table: field,
+					row
+				});
+			};
+			button.addEventListener("click", handler);
+			removeHandlers.set(button, handler);
+		});
+	};
+	const addRow = async () => {
+		if (options.static || !(addButton instanceof HTMLButtonElement)) return;
+		if (!addButton.getAttribute("data-formie-table-add")) return;
+		const templateId = addButton.getAttribute(TEMPLATE_ID_ATTR) || field.getAttribute(TEMPLATE_ID_ATTR);
+		const maxRows = parseInt(addButton.getAttribute("data-formie-max-rows") || "", 10);
+		if (maxRows > 0 && getRowCount(field) >= maxRows) return;
+		const template = getTemplate(field, templateId);
+		if (!template) return;
+		const html = getTemplateSourceHtml(template).replaceAll("__ROW__", String(rowCounter++));
+		const row = document.createElement("tr");
+		row.setAttribute("data-formie-table-row", "true");
+		row.setAttribute(ROW_ID_ATTR, String(rowCounter - 1));
+		row.innerHTML = html;
+		tbody.appendChild(row);
+		await sleep(50);
+		bindRemoveButtons();
+		syncAddButton(addButton, getRowCount(field));
+		dispatchFieldEvent(field, MODULE_ID, "append", {
+			table: field,
+			row
+		});
+	};
+	const addHandler = (event) => {
+		event.preventDefault();
+		addRow();
+	};
+	if (addButton instanceof HTMLButtonElement && !options.static) addButton.addEventListener("click", addHandler);
+	bindRemoveButtons();
+	syncAddButton(addButton instanceof HTMLButtonElement ? addButton : null, getRowCount(field));
+	dispatchFieldEvent(field, MODULE_ID, "init", { table: field });
+	return () => {
+		if (addButton instanceof HTMLButtonElement) addButton.removeEventListener("click", addHandler);
+		removeHandlers.forEach((handler, button) => {
+			button.removeEventListener("click", handler);
+		});
+	};
+}
+var tableModule = {
+	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) => {
+		const options = ctx.options || {};
+		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;
+		});
+		const destroyBindings = fields.map((field) => {
+			return bindTableField(field, options);
+		});
+		await ctx.emit("formie:module:table:init", { count: fields.length });
+		return { destroy: () => {
+			destroyBindings.forEach((destroyBinding) => {
+				destroyBinding();
+			});
+			ctx.emit("formie:module:table:destroy", {});
+		} };
+	}
+};
+//#endregion
+export { tableModule };