@verbb/formie-browser 1.0.0

package/dist/chunks/go-cardless-CuND59rR.js

@@ -0,0 +1,26 @@
+import { s as getPaymentProviderActionEventName } from "./event-names-DamGPtXR.js";
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+//#region src/js/modules/payments/go-cardless.ts
+/** Event name from PHP addSubmitData – dispatched on form when backend returns GoCardless redirect URL */
+var REDIRECT_EVENT = getPaymentProviderActionEventName("go-cardless", "redirect");
+var goCardlessModule = definePaymentModule({
+	id: "go-cardless",
+	defaultRequiredInputSuffixes: [],
+	load: async () => null,
+	setup: async ({ services, root }) => {
+		const handler = (event) => {
+			const data = event.detail?.data;
+			if (!data?.redirectUrl) {
+				services.addError("Missing GoCardless redirect URL.");
+				return;
+			}
+			window.location.href = data.redirectUrl;
+		};
+		root.addEventListener(REDIRECT_EVENT, handler);
+		return { destroy: () => {
+			root.removeEventListener(REDIRECT_EVENT, handler);
+		} };
+	}
+});
+//#endregion
+export { goCardlessModule };

package/dist/chunks/google-address--uR8WDSm.js

@@ -0,0 +1,208 @@
+import { n as getAddressProviderEventName } from "./event-names-DamGPtXR.js";
+import { t as defineAddressModule } from "./api-CbqEMQT5.js";
+import { n as loadExternalScript, t as ensureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/address/google-address.ts
+var SCRIPT_ID = "FORMIE_GOOGLE_ADDRESS_SCRIPT";
+var CALLBACK_NAME = "formieGoogleMapsReady";
+var loadPromise = null;
+/** Load Google Maps with callback; required when using loading=async. */
+async function loadGoogleMapsScript(apiKey) {
+	const w = window;
+	const existing = w.google;
+	if (typeof existing !== "undefined" && existing !== null) {
+		const maps = existing.maps;
+		if (maps?.places?.PlaceAutocompleteElement) return existing;
+		const imp = maps;
+		if (typeof imp?.importLibrary === "function") await imp.importLibrary("places");
+		return existing;
+	}
+	if (loadPromise) return loadPromise;
+	if (document.getElementById(SCRIPT_ID)) {
+		const google = await ensureGlobal("google", 1e4);
+		const maps = google?.maps;
+		if (typeof maps?.importLibrary === "function") await maps.importLibrary("places");
+		return google;
+	}
+	const url = new URL("https://maps.googleapis.com/maps/api/js");
+	url.searchParams.set("key", apiKey);
+	url.searchParams.set("loading", "async");
+	url.searchParams.set("libraries", "places");
+	url.searchParams.set("callback", CALLBACK_NAME);
+	loadPromise = (async () => {
+		const ready = new Promise((resolve, reject) => {
+			const t = setTimeout(() => {
+				if (w[CALLBACK_NAME]) {
+					delete w[CALLBACK_NAME];
+					reject(/* @__PURE__ */ new Error("Google Maps API load timeout"));
+				}
+			}, 15e3);
+			w[CALLBACK_NAME] = () => {
+				clearTimeout(t);
+				delete w[CALLBACK_NAME];
+				resolve(w.google);
+			};
+		});
+		await loadExternalScript({
+			id: SCRIPT_ID,
+			src: url.toString(),
+			async: true,
+			defer: true
+		});
+		const google = await ready;
+		const maps = google?.maps;
+		if (typeof maps?.importLibrary === "function") await maps.importLibrary("places");
+		return google;
+	})();
+	try {
+		return await loadPromise;
+	} catch (e) {
+		loadPromise = null;
+		throw e;
+	}
+}
+function setFieldValues(services, data) {
+	if (data.formattedAddress) services.input.setValue("autoComplete", data.formattedAddress);
+	if (data.address1) services.input.setValue("address1", data.address1);
+	if (data.city !== void 0) services.input.setValue("city", data.city);
+	if (data.state !== void 0) services.input.setValue("state", data.state);
+	if (data.zip !== void 0) services.input.setValue("zip", data.zip);
+	if (data.country !== void 0) services.input.setValue("country", data.country);
+}
+function componentMap() {
+	return {
+		subpremise: "shortText",
+		street_number: "shortText",
+		route: "longText",
+		postal_town: "longText",
+		locality: "longText",
+		administrative_area_level_1: "shortText",
+		country: "shortText",
+		postal_code: "shortText"
+	};
+}
+function parseAddressComponents(components) {
+	const map = componentMap();
+	const out = {};
+	for (const comp of components) {
+		const type = comp.types?.[0];
+		if (!type || !map[type]) continue;
+		out[type] = comp[map[type]] ?? comp.short_text ?? comp.long_text ?? "";
+	}
+	return out;
+}
+function buildAddressFromComponents(formData) {
+	let address1 = "";
+	if (formData.street_number || formData.route) {
+		address1 = [formData.street_number, formData.route].filter(Boolean).join(" ");
+		if (formData.subpremise) address1 = `${formData.subpremise}/${address1}`;
+	}
+	return {
+		address1,
+		city: formData.locality || formData.postal_town || "",
+		state: formData.administrative_area_level_1 || "",
+		zip: formData.postal_code || "",
+		country: formData.country || ""
+	};
+}
+var googleAddressModule = defineAddressModule({
+	id: "google-address",
+	load: async ({ options }) => {
+		const apiKey = options.provider.apiKey;
+		if (!apiKey) throw new Error("Google Places API key is required");
+		return loadGoogleMapsScript(apiKey);
+	},
+	mount: async ({ api, field, services, provider }) => {
+		const input = services.input.getAutocomplete();
+		const PlaceAutocompleteElement = api?.maps?.places?.PlaceAutocompleteElement;
+		if (!input || typeof PlaceAutocompleteElement !== "function") {
+			console.warn("[formie] Google Places API not ready; address autocomplete skipped.");
+			return null;
+		}
+		const autocomplete = new PlaceAutocompleteElement({
+			types: ["geocode"],
+			...provider.options || {}
+		});
+		const inputHeight = window.getComputedStyle(input).height;
+		autocomplete.style.height = inputHeight;
+		autocomplete.style.boxSizing = "border-box";
+		let wrapper = input.parentElement;
+		if (!wrapper?.classList.contains("formie-autocomplete-wrapper")) {
+			wrapper = document.createElement("div");
+			wrapper.classList.add("formie-autocomplete-wrapper");
+			input.parentNode?.insertBefore(wrapper, input);
+			wrapper.appendChild(input);
+		}
+		const savedValue = input.value;
+		if (savedValue) {
+			const overlay = document.createElement("div");
+			overlay.classList.add("formie-autocomplete-placeholder");
+			overlay.textContent = savedValue;
+			wrapper.style.position = "relative";
+			overlay.style.cssText = `
+                position: absolute; left: 0; top: 0; height: ${inputHeight};
+                line-height: ${inputHeight}; width: 100%; padding: 0 2.5rem;
+                pointer-events: none; color: #6B7280; font-size: 14px; z-index: 1;
+            `;
+			wrapper.appendChild(overlay);
+			autocomplete.addEventListener("focusin", () => {
+				overlay.style.display = "none";
+			});
+			autocomplete.addEventListener("focusout", () => {
+				if (input.value) overlay.style.display = "";
+			});
+		}
+		wrapper.replaceChild(autocomplete, input);
+		input.type = "hidden";
+		input.name = input.getAttribute("name") || "";
+		wrapper.appendChild(input);
+		const onSelect = async (ev) => {
+			const pred = ev.placePrediction;
+			if (!pred) return;
+			const place = await pred.toPlace();
+			await place.fetchFields({ fields: ["addressComponents", "formattedAddress"] });
+			if (!place.addressComponents) return;
+			setFieldValues(services, {
+				...buildAddressFromComponents(parseAddressComponents(place.addressComponents)),
+				formattedAddress: place.formattedAddress
+			});
+			field.dispatchEvent(new CustomEvent(getAddressProviderEventName("google", "populate"), {
+				bubbles: true,
+				detail: {
+					addressProvider: "google",
+					place,
+					formattedAddress: place.formattedAddress,
+					addressComponents: place.addressComponents
+				}
+			}));
+		};
+		autocomplete.addEventListener("gmp-select", onSelect);
+		return autocomplete;
+	},
+	onCurrentLocation: async (position, { field, services }) => {
+		const { latitude, longitude } = position.coords;
+		const form = services.form;
+		const actionUrl = form?.action || window.location.href;
+		const fieldHandle = field.getAttribute("data-formie-field-handle")?.trim();
+		const formHandle = (form?.querySelector("[name=\"handle\"]"))?.value?.trim();
+		if (!formHandle || !fieldHandle) return;
+		try {
+			const formData = new FormData();
+			formData.append("action", "formie/address/google-places-geocode");
+			formData.append("latlng", `${latitude},${longitude}`);
+			formData.append("handle", formHandle);
+			formData.append("fieldHandle", fieldHandle);
+			const data = await (await fetch(actionUrl, {
+				method: "POST",
+				body: formData,
+				credentials: "include",
+				headers: {
+					"X-Requested-With": "XMLHttpRequest",
+					Accept: "application/json"
+				}
+			})).json();
+			if (data?.results?.[0]?.address_components) setFieldValues(services, buildAddressFromComponents(parseAddressComponents(data.results[0].address_components)));
+		} catch {}
+	}
+});
+//#endregion
+export { googleAddressModule };

package/dist/chunks/hcaptcha-CmaFUesv.js

@@ -0,0 +1,72 @@
+import { a as CAPTCHA_PROVIDER_LOAD_TIMEOUT_MS, r as getScriptAttributes, t as defineCaptchaModule } from "./api-DOfDzYC_.js";
+import { n as loadExternalScript, t as ensureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/captchas/hcaptcha.ts
+async function loadHcaptchaGlobal(options) {
+	const language = typeof options.language === "string" && options.language.trim() !== "" ? options.language.trim() : "en";
+	const { async, defer } = getScriptAttributes(options.loadingMethod);
+	const callbackName = "FORMIE_HCAPTCHA_ONLOAD";
+	const globalWindow = window;
+	const existing = globalWindow.hcaptcha;
+	if (existing) return existing;
+	const callbackPromise = new Promise((resolve) => {
+		globalWindow[callbackName] = () => {
+			delete globalWindow[callbackName];
+			resolve();
+		};
+	});
+	await loadExternalScript({
+		id: "FORMIE_HCAPTCHA_SCRIPT",
+		src: `https://js.hcaptcha.com/1/api.js?recaptchacompat=off&render=explicit&onload=${encodeURIComponent(callbackName)}&hl=${encodeURIComponent(language)}`,
+		async,
+		defer
+	});
+	await callbackPromise;
+	return ensureGlobal("hcaptcha", CAPTCHA_PROVIDER_LOAD_TIMEOUT_MS);
+}
+var hcaptchaModule = defineCaptchaModule({
+	id: "hcaptcha",
+	defaultPlaceholderSelector: "[data-hcaptcha-placeholder]",
+	defaultTokenFieldNames: ["h-captcha-response"],
+	load: ({ options }) => {
+		return loadHcaptchaGlobal(options.provider);
+	},
+	mount: ({ api, container, provider, services }) => {
+		return api.render(container, {
+			sitekey: provider.siteKey || "",
+			theme: provider.theme || "light",
+			size: provider.size || "normal",
+			callback: (token) => {
+				if (typeof token === "string" && token.trim() !== "") services.tokens.write(token.trim());
+				services.errors.clear();
+			},
+			"expired-callback": () => {
+				services.tokens.clear();
+				services.errors.clear();
+			},
+			"chalexpired-callback": () => {
+				services.tokens.clear();
+				services.errors.clear();
+			},
+			"error-callback": () => {
+				services.tokens.clear();
+			}
+		});
+	},
+	screen: ({ api, widget, placeholder, services, stageCtx }) => {
+		if (services.tokens.has()) return;
+		api.execute(widget);
+		return services.tokens.wait().then((hasToken) => {
+			if (!hasToken) {
+				const message = services.errors.getDefaultMessage();
+				services.errors.show(message, placeholder);
+				stageCtx.abort(message);
+			}
+		});
+	},
+	unmount: ({ api, widget, services }) => {
+		api.reset(widget);
+		services.tokens.clear();
+	}
+});
+//#endregion
+export { hcaptchaModule };

package/dist/chunks/hidden-CYnZYple.js

@@ -0,0 +1,36 @@
+import { r as getModuleFieldContainers } from "./shared-DC6_1u8X.js";
+//#region src/js/modules/fields/hidden.ts
+var INPUT_SELECTOR = "input[data-formie-hidden-input]";
+function getCookieValue(name) {
+	const cookies = document.cookie ? document.cookie.split("; ") : [];
+	for (const cookie of cookies) {
+		const parts = cookie.split("=");
+		if (decodeURIComponent(parts.shift() || "") === name) return decodeURIComponent(parts.join("="));
+	}
+	return null;
+}
+var hiddenModule = {
+	id: "hidden",
+	kind: "field",
+	match: (ctx) => {
+		return !!ctx.target.querySelector(INPUT_SELECTOR);
+	},
+	setup: async (ctx) => {
+		const options = ctx.options || {};
+		const cookieValue = options.cookieName ? getCookieValue(options.cookieName) : null;
+		const inputs = getModuleFieldContainers(ctx).map((field) => {
+			return field.querySelector(INPUT_SELECTOR);
+		}).filter((input) => {
+			return input instanceof HTMLInputElement;
+		});
+		if (cookieValue !== null) inputs.forEach((input) => {
+			input.value = cookieValue;
+		});
+		await ctx.emit("formie:module:hidden:init", { count: inputs.length });
+		return { destroy: () => {
+			ctx.emit("formie:module:hidden:destroy", {});
+		} };
+	}
+};
+//#endregion
+export { hiddenModule };

package/dist/chunks/http-18nn97DZ.js

@@ -0,0 +1,29 @@
+//#region src/js/utils/http.ts
+async function request(url, options = {}) {
+	const headers = {
+		Accept: "application/json",
+		...options.headers || {}
+	};
+	delete headers["X-Requested-With"];
+	delete headers["x-requested-with"];
+	return fetch(String(url), {
+		method: options.method || "GET",
+		body: options.body ?? null,
+		signal: options.signal,
+		cache: "no-store",
+		headers,
+		credentials: "same-origin"
+	});
+}
+async function requestJson(url, options = {}) {
+	const response = await request(url, options);
+	if (!response.ok) throw new Error(`Request failed (${response.status}) for ${String(url)}`);
+	return response.json();
+}
+async function requestText(url, options = {}) {
+	const response = await request(url, options);
+	if (!response.ok) throw new Error(`Request failed (${response.status}) for ${String(url)}`);
+	return response.text();
+}
+//#endregion
+export { requestText as n, requestJson as t };

package/dist/chunks/i18n-vUh-KGiH.js

@@ -0,0 +1,55 @@
+//#region src/js/utils/i18n.ts
+function getWindowTranslationStore() {
+	return window.FormieTranslations || {};
+}
+function hydrateTranslationsFromDom() {
+	if (typeof document === "undefined") return;
+	const scripts = Array.from(document.querySelectorAll("script[type=\"application/json\"][data-formie-translations]:not([data-formie-translations-loaded=\"true\"])"));
+	if (scripts.length === 0) return;
+	let nextStore = null;
+	for (const script of scripts) {
+		script.dataset.formieTranslationsLoaded = "true";
+		const payload = script.textContent?.trim();
+		if (!payload) continue;
+		try {
+			const translations = JSON.parse(payload);
+			if (!translations || Array.isArray(translations) || typeof translations !== "object") continue;
+			nextStore = {
+				...nextStore ?? getWindowTranslationStore(),
+				...translations
+			};
+		} catch {
+			continue;
+		}
+	}
+	if (nextStore) window.FormieTranslations = nextStore;
+}
+function getTranslationStore() {
+	hydrateTranslationsFromDom();
+	return getWindowTranslationStore();
+}
+function getFormieTranslations() {
+	return { ...getTranslationStore() };
+}
+function setFormieTranslations(translations) {
+	window.FormieTranslations = { ...translations };
+	return getFormieTranslations();
+}
+function mergeFormieTranslations(translations) {
+	window.FormieTranslations = {
+		...getTranslationStore(),
+		...translations
+	};
+	return getFormieTranslations();
+}
+function t(message, replacements = {}) {
+	let output = getTranslationStore()[message] || message;
+	output = output.replace(/{([a-zA-Z0-9]+)}/g, (match, key) => {
+		if (Object.prototype.hasOwnProperty.call(replacements, key)) return String(replacements[key]);
+		return match;
+	});
+	return output;
+}
+var translate = t;
+//#endregion
+export { translate as a, t as i, mergeFormieTranslations as n, setFormieTranslations as r, getFormieTranslations as t };

package/dist/chunks/loqate-BICNJlVK.js

@@ -0,0 +1,97 @@
+import { n as ADDRESS_SELECTORS, t as defineAddressModule } from "./api-CbqEMQT5.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/address/loqate.ts
+var SCRIPT_ID = "FORMIE_LOQATE_SCRIPT";
+var loqateModule = defineAddressModule({
+	id: "loqate",
+	load: async () => {
+		await loadScriptAndEnsureGlobal("pca", {
+			id: SCRIPT_ID,
+			src: "https://services.pcapredict.com/js/address-3.91.min.js",
+			async: true,
+			defer: true
+		});
+		const link = document.createElement("link");
+		link.href = "https://services.pcapredict.com/css/address-3.91.min.css";
+		link.rel = "stylesheet";
+		link.type = "text/css";
+		if (!document.querySelector(`link[href="${link.href}"]`)) document.body.appendChild(link);
+		return window.pca;
+	},
+	mount: ({ api, field, services, provider }) => {
+		const namespace = provider.namespace || "";
+		const apiKey = provider.apiKey || "";
+		if (!apiKey) throw new Error("Loqate API key is required");
+		const handleToSelector = {
+			autoComplete: ADDRESS_SELECTORS.autoComplete,
+			address1: ADDRESS_SELECTORS.address1,
+			address2: ADDRESS_SELECTORS.address2,
+			address3: ADDRESS_SELECTORS.address3,
+			city: ADDRESS_SELECTORS.city,
+			state: ADDRESS_SELECTORS.state,
+			zip: ADDRESS_SELECTORS.zip,
+			country: ADDRESS_SELECTORS.country
+		};
+		const getLoqateElementRef = (handle) => {
+			if (namespace) return `${namespace}[${handle}]`;
+			const cssSelector = handleToSelector[handle];
+			const el = cssSelector ? field.querySelector(cssSelector) : null;
+			if (el?.name) return el.name;
+			if (el?.id) return el.id;
+			return "";
+		};
+		const autoCompleteRef = getLoqateElementRef("autoComplete");
+		if (!autoCompleteRef) throw new Error("Loqate: could not find autocomplete input within address field");
+		const fields = [
+			{
+				element: autoCompleteRef,
+				field: "",
+				mode: api.fieldMode.SEARCH
+			},
+			{
+				element: getLoqateElementRef("address1"),
+				field: "Line1",
+				mode: api.fieldMode.POPULATE
+			},
+			{
+				element: getLoqateElementRef("address2"),
+				field: "Line2",
+				mode: api.fieldMode.POPULATE
+			},
+			{
+				element: getLoqateElementRef("address3"),
+				field: "Line3",
+				mode: api.fieldMode.POPULATE
+			},
+			{
+				element: getLoqateElementRef("city"),
+				field: "City",
+				mode: api.fieldMode.POPULATE
+			},
+			{
+				element: getLoqateElementRef("state"),
+				field: "Province",
+				mode: api.fieldMode.POPULATE
+			},
+			{
+				element: getLoqateElementRef("zip"),
+				field: "PostalCode",
+				mode: api.fieldMode.POPULATE
+			},
+			{
+				element: getLoqateElementRef("country"),
+				field: "CountryName",
+				mode: api.fieldMode.COUNTRY
+			}
+		].filter((f) => f.element);
+		const control = new api.Address(fields, {
+			key: apiKey,
+			simulateReactEvents: true,
+			...provider.reconfigurableOptions || {}
+		});
+		if (typeof control.load === "function") control.load();
+		return control;
+	}
+});
+//#endregion
+export { loqateModule };

package/dist/chunks/mollie-DwlsgHZ1.js

@@ -0,0 +1,26 @@
+import { s as getPaymentProviderActionEventName } from "./event-names-DamGPtXR.js";
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+//#region src/js/modules/payments/mollie.ts
+/** Event name from PHP addSubmitData – dispatched on form when backend returns Mollie checkout URL */
+var REDIRECT_EVENT = getPaymentProviderActionEventName("mollie", "redirect");
+var mollieModule = definePaymentModule({
+	id: "mollie",
+	defaultRequiredInputSuffixes: [],
+	load: async () => null,
+	setup: async ({ services, root }) => {
+		const handler = (event) => {
+			const data = event.detail?.data;
+			if (!data?.checkoutUrl) {
+				services.addError("Missing Mollie checkout URL.");
+				return;
+			}
+			window.location.href = data.checkoutUrl;
+		};
+		root.addEventListener(REDIRECT_EVENT, handler);
+		return { destroy: () => {
+			root.removeEventListener(REDIRECT_EVENT, handler);
+		} };
+	}
+});
+//#endregion
+export { mollieModule };