@verbb/formie-browser 1.0.0

package/dist/chunks/event-names-DamGPtXR.js

@@ -0,0 +1,51 @@
+//#region src/js/utils/event-names.ts
+var FORMIE_HTML_EVENT_NAMES = [
+	"formie:mount:after",
+	"formie:unmount:before",
+	"formie:unmount:after",
+	"formie:validator:ready",
+	"formie:theme:applied",
+	"formie:page:navigate",
+	"formie:page:navigate:after",
+	"formie:page:navigate:error",
+	"formie:submit:before",
+	"formie:submit:after",
+	"formie:submit:final:before",
+	"formie:submit:final:after",
+	"formie:submit:result",
+	"formie:client-event",
+	"formie:refresh-tokens:after",
+	"formie:refresh-tokens:refreshed"
+];
+function toDomEventName(eventName) {
+	return normalizeFormieEventName(eventName);
+}
+function normalizeFormieEventName(eventName) {
+	return eventName;
+}
+function getFieldModuleEventName(moduleId, name) {
+	return `formie:field:${moduleId}:${name}`;
+}
+function getValidatorEventName(name) {
+	return `formie:validator:${name}`;
+}
+function getAddressProviderEventName(providerId, name) {
+	return `formie:address:${providerId}:${name}`;
+}
+function getFileUploadEventName(name) {
+	return `formie:file-upload:${name}`;
+}
+function getPaymentProviderActionEventName(providerId, action) {
+	return `formie:payment:${providerId}:${action}`;
+}
+function getFormStateEventName(name) {
+	return `formie:state:${name}`;
+}
+function getScopedModuleLifecycleEventName(moduleId, phase) {
+	return `formie:module:${moduleId}:${phase}`;
+}
+function getGlobalModuleLifecycleEventName(phase) {
+	return `formie:module:${phase}`;
+}
+//#endregion
+export { getFormStateEventName as a, getScopedModuleLifecycleEventName as c, toDomEventName as d, getFileUploadEventName as i, getValidatorEventName as l, getAddressProviderEventName as n, getGlobalModuleLifecycleEventName as o, getFieldModuleEventName as r, getPaymentProviderActionEventName as s, FORMIE_HTML_EVENT_NAMES as t, normalizeFormieEventName as u };

package/dist/chunks/eway-DEAYcwT0.js

@@ -0,0 +1,86 @@
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+import { r as waitFor } from "./async-B3DUf1GZ.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/payments/eway.ts
+var SCRIPT_SOURCES = [{
+	id: "FORMIE_EWAY_SCRIPT_MIN",
+	src: "https://secure.ewaypayments.com/scripts/eCrypt.min.js"
+}, {
+	id: "FORMIE_EWAY_SCRIPT",
+	src: "https://secure.ewaypayments.com/scripts/eCrypt.js"
+}];
+async function ensureEwayEncryptApi() {
+	let lastError = null;
+	for (const source of SCRIPT_SOURCES) {
+		try {
+			await loadScriptAndEnsureGlobal("eCrypt", {
+				id: source.id,
+				src: source.src,
+				timeoutMs: 1e4
+			});
+			return await waitFor(() => {
+				const candidate = window.eCrypt;
+				if (candidate && typeof candidate.encryptValue === "function") return candidate;
+				return null;
+			}, {
+				timeoutMs: 1e4,
+				intervalMs: 50
+			});
+		} catch (error) {
+			lastError = error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown eWay script load error.");
+		}
+		SCRIPT_SOURCES.forEach(({ id }) => {
+			document.getElementById(id)?.remove();
+		});
+	}
+	throw lastError || /* @__PURE__ */ new Error("Eway encryption script failed to load.");
+}
+var ewayModule = definePaymentModule({
+	id: "eway",
+	defaultRequiredInputSuffixes: ["ewayTokenData"],
+	load: async (ctx) => {
+		const { provider } = ctx.options;
+		if (!provider.cseKey?.trim()) {
+			console.error("[formie] Missing cseKey for Eway.");
+			return null;
+		}
+		return ensureEwayEncryptApi();
+	},
+	onBeforeAuthorize: async (args) => {
+		const { field, services, provider, api } = args;
+		const cseKey = provider.cseKey;
+		if (!cseKey?.trim()) {
+			services.addError("Missing cseKey for Eway.");
+			return false;
+		}
+		let eCrypt = api;
+		if (!eCrypt?.encryptValue) try {
+			eCrypt = await ensureEwayEncryptApi();
+		} catch (error) {
+			services.addError(error instanceof Error ? error.message : "Eway encryption script failed to load.");
+			return false;
+		}
+		const cardholderName = field.querySelector("[data-eway-card=\"cardholder-name\"]")?.value ?? "";
+		const cardNumber = field.querySelector("[data-eway-card=\"card-number\"]")?.value ?? "";
+		const expiryDate = field.querySelector("[data-eway-card=\"expiry-date\"]")?.value ?? "";
+		const securityCode = field.querySelector("[data-eway-card=\"security-code\"]")?.value ?? "";
+		try {
+			const cardDetails = {
+				cardholderName,
+				cardNumber: eCrypt.encryptValue(cardNumber, cseKey),
+				expiryDate,
+				securityCode: eCrypt.encryptValue(securityCode, cseKey)
+			};
+			services.updateInputs("ewayTokenData", JSON.stringify(cardDetails));
+			return true;
+		} catch (e) {
+			services.addError(e instanceof Error ? e.message : "Failed to encrypt card details.");
+			return false;
+		}
+	},
+	onAfterSubmit: async ({ services }) => {
+		services.updateInputs("ewayTokenData", "");
+	}
+});
+//#endregion
+export { ewayModule };

package/dist/chunks/field-references.keys-BpBZ_quS.js

@@ -0,0 +1,24 @@
+//#region src/js/utils/field-references.keys.ts
+function stripFieldPrefix(value) {
+	return value.replace(/^\{field:/, "").replace(/^\{/, "").replace(/\}$/, "").trim();
+}
+function normalizeFieldKey(value) {
+	return stripFieldPrefix(value).replace(/\]/g, "").split("[").join(".").replace(/\.+/g, ".").replace(/^\./, "").replace(/\.$/, "");
+}
+function fieldKeyToInputName(key) {
+	const parts = normalizeFieldKey(key).split(".").filter(Boolean);
+	if (!parts.length) return "";
+	const [head, ...rest] = parts;
+	return `fields[${head}]${rest.map((part) => `[${part}]`).join("")}`;
+}
+function inputNameToFieldKey(name) {
+	const match = String(name || "").trim().match(/^fields\[([^\]]+)\](.*)$/);
+	if (!match) return "";
+	const first = match[1] || "";
+	const tail = match[2] || "";
+	return [first, ...Array.from(tail.matchAll(/\[([^\]]+)\]/g)).map((part) => {
+		return part[1] || "";
+	}).filter(Boolean)].join(".");
+}
+//#endregion
+export { inputNameToFieldKey as n, normalizeFieldKey as r, fieldKeyToInputName as t };

package/dist/chunks/field-references.resolver-Ba6xhiJC.js

@@ -0,0 +1,183 @@
+import { n as inputNameToFieldKey, r as normalizeFieldKey, t as fieldKeyToInputName } from "./field-references.keys-BpBZ_quS.js";
+//#region src/js/utils/field-references.parser.ts
+function parseTransforms(body) {
+	const parts = body.split(";").map((part) => {
+		return part.trim();
+	}).filter(Boolean);
+	if (!parts.length) return {
+		source: "",
+		transforms: []
+	};
+	const [source, ...metadata] = parts;
+	const transforms = [];
+	let current = null;
+	metadata.forEach((entry) => {
+		if (entry.startsWith("transform=")) {
+			if (current) transforms.push(current);
+			current = {
+				id: decodeURIComponent(entry.slice(10) || "").trim(),
+				params: {}
+			};
+			return;
+		}
+		if (!current || !entry.includes("=")) return;
+		const [rawKey, rawValue] = entry.split("=", 2);
+		const key = (rawKey || "").trim();
+		if (!key || key === "transform") return;
+		current.params[key] = decodeURIComponent(rawValue || "").trim();
+	});
+	if (current) transforms.push(current);
+	return {
+		source: source || "",
+		transforms
+	};
+}
+function parseFieldReference(rawValue) {
+	const raw = String(rawValue || "").trim();
+	if (!raw) return {
+		raw,
+		target: "",
+		key: "",
+		selector: "",
+		defaultValue: "",
+		transforms: [],
+		isToken: false,
+		isValid: false
+	};
+	const tokenMatch = raw.match(/^\{([a-zA-Z]+)(?::(.*))?\}$/);
+	if (!tokenMatch) return {
+		raw,
+		target: "",
+		key: normalizeFieldKey(raw),
+		selector: "",
+		defaultValue: "",
+		transforms: [],
+		isToken: false,
+		isValid: true
+	};
+	const targetRaw = (tokenMatch[1] || "").trim().toLowerCase();
+	const [beforeDefault, defaultRaw = ""] = (tokenMatch[2] || "").trim().split("|", 2);
+	const { source, transforms } = parseTransforms(beforeDefault || "");
+	if (targetRaw !== "field") return {
+		raw,
+		target: "",
+		key: "",
+		selector: "",
+		defaultValue: defaultRaw.trim(),
+		transforms,
+		isToken: true,
+		isValid: false
+	};
+	const separatorIndex = source.indexOf(":");
+	const keyRaw = separatorIndex === -1 ? source : source.slice(0, separatorIndex);
+	const selectorRaw = separatorIndex === -1 ? "" : source.slice(separatorIndex + 1);
+	const key = normalizeFieldKey(keyRaw);
+	return {
+		raw,
+		target: "field",
+		key,
+		selector: selectorRaw.trim(),
+		defaultValue: defaultRaw.trim(),
+		transforms,
+		isToken: true,
+		isValid: key !== ""
+	};
+}
+//#endregion
+//#region src/js/utils/field-references.registry.ts
+function isFieldValueInput(node) {
+	return node instanceof HTMLInputElement || node instanceof HTMLTextAreaElement || node instanceof HTMLSelectElement;
+}
+function addInputEntry(registry, key, input) {
+	const normalizedKey = key.trim();
+	const name = String(input.name || "").trim();
+	if (!normalizedKey || !name) return;
+	const entry = registry.get(normalizedKey) || {
+		key: normalizedKey,
+		names: [],
+		inputs: []
+	};
+	if (!entry.names.includes(name)) entry.names.push(name);
+	if (!entry.inputs.includes(input)) entry.inputs.push(input);
+	registry.set(normalizedKey, entry);
+}
+function buildFieldValueRegistry(root) {
+	const registry = /* @__PURE__ */ new Map();
+	Array.from(root.querySelectorAll("[name]")).filter((node) => {
+		return isFieldValueInput(node);
+	}).forEach((input) => {
+		const key = inputNameToFieldKey(input.name);
+		if (!key) return;
+		addInputEntry(registry, key, input);
+	});
+	return registry;
+}
+//#endregion
+//#region src/js/utils/field-references.resolver.ts
+function readInputsValue(inputs) {
+	if (!inputs.length) return "";
+	const first = inputs[0];
+	if (first instanceof HTMLSelectElement && first.multiple) return Array.from(first.selectedOptions).map((option) => {
+		return option.value;
+	});
+	if (inputs.some((input) => {
+		return input instanceof HTMLInputElement && (input.type === "checkbox" || input.type === "radio");
+	})) {
+		const selected = inputs.flatMap((input) => {
+			if (!(input instanceof HTMLInputElement) || !input.checked) return [];
+			return [input.value];
+		});
+		return selected.length > 1 ? selected : selected[0] || "";
+	}
+	return first.value;
+}
+function getEntry(registry, key) {
+	return registry.get(normalizeFieldKey(key)) || null;
+}
+function resolveFieldReferenceLive(reference, registry) {
+	const parsed = parseFieldReference(reference);
+	const key = parsed.key;
+	const entry = getEntry(registry, key);
+	if (!entry) return {
+		key,
+		value: parsed.defaultValue,
+		found: false
+	};
+	const value = readInputsValue(entry.inputs);
+	return {
+		key,
+		value: value === "" && parsed.defaultValue !== "" ? parsed.defaultValue : value,
+		found: true
+	};
+}
+function resolveFieldReferenceFromFormData(reference, formData, registry) {
+	const parsed = parseFieldReference(reference);
+	const key = parsed.key;
+	if (!key) return {
+		key,
+		value: parsed.defaultValue,
+		found: false
+	};
+	const entry = registry ? getEntry(registry, key) : null;
+	const values = (entry?.names?.length ? entry.names : [fieldKeyToInputName(key)]).flatMap((name) => {
+		const collected = formData.getAll(name).map((value) => {
+			return String(value ?? "");
+		});
+		if (collected.length) return collected;
+		return formData.getAll(`${name}[]`).map((value) => {
+			return String(value ?? "");
+		});
+	}).filter((value) => value !== "");
+	if (!values.length) return {
+		key,
+		value: parsed.defaultValue,
+		found: false
+	};
+	return {
+		key,
+		value: values.length > 1 ? values : values[0],
+		found: true
+	};
+}
+//#endregion
+export { parseFieldReference as i, resolveFieldReferenceLive as n, buildFieldValueRegistry as r, resolveFieldReferenceFromFormData as t };