@verbb/formie-browser 1.0.1 → 1.0.2

package/dist/chunks/text-limit-CgBMu4sJ.js

@@ -1,177 +0,0 @@
-import { t as ensureModuleStyles } from "./styles-BIh6g7V_.js";
-import { r as Le } from "./dist-D09GnXMW.js";
-import { c as retainFormValidators, i as getModuleFieldTarget, s as releaseFormValidators } from "./shared-DC6_1u8X.js";
-import textLimitCss from "#theme/fields/_text-limit.css?inline";
-//#region src/js/modules/fields/text-limit.ts
-var INPUT_SELECTOR = "input[data-formie-single-line-text-input], textarea[data-formie-multi-line-text-input]";
-var TEXT_LIMIT_VALIDATORS = [
-	"textMinCharacterLimit",
-	"textMaxCharacterLimit",
-	"textMinWordLimit",
-	"textMaxWordLimit"
-];
-var VALIDATOR_SCOPE = "text-limit";
-var ALLOW_OVERTYPE_ATTR = "data-formie-text-limit-allow-overtype";
-var limitTargetCache = /* @__PURE__ */ new WeakMap();
-ensureModuleStyles("text-limit", [textLimitCss]);
-function isTextLimitInput(input) {
-	return input instanceof HTMLInputElement || input instanceof HTMLTextAreaElement;
-}
-function getLimitValue(input, attribute) {
-	return parseInt(input.getAttribute(attribute) || "", 10) || 0;
-}
-function hasAnyLimitAttributes(input) {
-	return input.hasAttribute("data-formie-min-chars") || input.hasAttribute("data-formie-max-chars") || input.hasAttribute("data-formie-min-words") || input.hasAttribute("data-formie-max-words");
-}
-function hasCounterLimitAttributes(input) {
-	return input.hasAttribute("data-formie-max-chars") || input.hasAttribute("data-formie-max-words");
-}
-function allowsOvertype(input) {
-	return input.hasAttribute(ALLOW_OVERTYPE_ATTR);
-}
-function hasNoRawValue(input) {
-	return input.value === "";
-}
-function registerValidators(form) {
-	retainFormValidators(form, VALIDATOR_SCOPE, (validator) => {
-		validator.addValidator("textMinCharacterLimit", ({ input }) => {
-			if (!isTextLimitInput(input)) return true;
-			const limit = getLimitValue(input, "data-formie-min-chars");
-			if (!limit || hasNoRawValue(input)) return true;
-			return Le(input.value).graphemeCount >= limit;
-		}, ({ label, input, t }) => {
-			return t("{attribute} must be no less than {min} characters.", {
-				attribute: label,
-				min: input.getAttribute("data-formie-min-chars") || ""
-			});
-		});
-		validator.addValidator("textMaxCharacterLimit", ({ input }) => {
-			if (!isTextLimitInput(input)) return true;
-			if (allowsOvertype(input)) return true;
-			const limit = getLimitValue(input, "data-formie-max-chars");
-			if (!limit || hasNoRawValue(input)) return true;
-			return Le(input.value).graphemeCount <= limit;
-		}, ({ label, input, t }) => {
-			return t("{attribute} must be no greater than {max} characters.", {
-				attribute: label,
-				max: input.getAttribute("data-formie-max-chars") || ""
-			});
-		});
-		validator.addValidator("textMinWordLimit", ({ input }) => {
-			if (!isTextLimitInput(input)) return true;
-			const limit = getLimitValue(input, "data-formie-min-words");
-			if (!limit || input.value.trim() === "") return true;
-			return Le(input.value).wordCount >= limit;
-		}, ({ label, input, t }) => {
-			return t("{attribute} must be no less than {min} words.", {
-				attribute: label,
-				min: input.getAttribute("data-formie-min-words") || ""
-			});
-		});
-		validator.addValidator("textMaxWordLimit", ({ input }) => {
-			if (!isTextLimitInput(input)) return true;
-			if (allowsOvertype(input)) return true;
-			const limit = getLimitValue(input, "data-formie-max-words");
-			if (!limit || input.value.trim() === "") return true;
-			return Le(input.value).wordCount <= limit;
-		}, ({ label, input, t }) => {
-			return t("{attribute} must be no greater than {max} words.", {
-				attribute: label,
-				max: input.getAttribute("data-formie-max-words") || ""
-			});
-		});
-	});
-}
-function unregisterValidators(form) {
-	releaseFormValidators(form, VALIDATOR_SCOPE, TEXT_LIMIT_VALIDATORS);
-}
-function getLimitTarget(input) {
-	if (limitTargetCache.has(input)) return limitTargetCache.get(input) || null;
-	const field = input.closest("[data-formie-field-handle]");
-	if (!field) {
-		limitTargetCache.set(input, null);
-		return null;
-	}
-	const existingTarget = field.querySelector("[data-formie-limit-text]");
-	if (existingTarget) {
-		limitTargetCache.set(input, existingTarget);
-		return existingTarget;
-	}
-	const control = field.querySelector("[data-formie-field-control]");
-	const target = document.createElement("div");
-	target.className = "formie-field-limit formie-limit-text";
-	target.setAttribute("data-formie-field-limit", "true");
-	target.setAttribute("data-formie-limit-text", "true");
-	if (control?.parentElement) {
-		control.insertAdjacentElement("afterend", target);
-		limitTargetCache.set(input, target);
-		return target;
-	}
-	field.appendChild(target);
-	limitTargetCache.set(input, target);
-	return target;
-}
-function renderCounter(target, remaining, unit) {
-	const number = document.createElement("span");
-	number.className = remaining < 0 ? "formie-limit-number formie-limit-number-error" : "formie-limit-number";
-	number.textContent = String(remaining);
-	target.replaceChildren(number, document.createTextNode(` ${Math.abs(remaining) === 1 ? unit : `${unit}s`} left`));
-}
-function updateCounter(input) {
-	const maxChars = getLimitValue(input, "data-formie-max-chars");
-	const maxWords = getLimitValue(input, "data-formie-max-words");
-	const target = getLimitTarget(input);
-	if (!target) return;
-	const metrics = Le(input.value);
-	if (maxChars > 0) {
-		renderCounter(target, maxChars - metrics.graphemeCount, "character");
-		return;
-	}
-	if (maxWords > 0) renderCounter(target, maxWords - metrics.wordCount, "word");
-}
-var textLimitModule = {
-	id: "text-limit",
-	kind: "field",
-	match: (ctx) => {
-		return !!ctx.target.querySelector(INPUT_SELECTOR);
-	},
-	setup: async (ctx) => {
-		const options = ctx.options || {};
-		const field = getModuleFieldTarget(ctx);
-		const inputs = Array.from((field || ctx.target).querySelectorAll(INPUT_SELECTOR)).filter((input) => {
-			return (input instanceof HTMLInputElement || input instanceof HTMLTextAreaElement) && hasAnyLimitAttributes(input);
-		});
-		const counterInputs = inputs.filter((input) => {
-			return hasCounterLimitAttributes(input);
-		});
-		if (options.allowOvertype) inputs.forEach((input) => {
-			input.setAttribute(ALLOW_OVERTYPE_ATTR, "true");
-		});
-		registerValidators(ctx.form);
-		const unbinds = counterInputs.map((input) => {
-			const handler = () => {
-				updateCounter(input);
-			};
-			input.addEventListener("input", handler);
-			input.addEventListener("change", handler);
-			updateCounter(input);
-			return () => {
-				input.removeEventListener("input", handler);
-				input.removeEventListener("change", handler);
-			};
-		});
-		await ctx.emit("formie:module:text-limit:init", { count: inputs.length });
-		return { destroy: () => {
-			unbinds.forEach((unbind) => {
-				unbind();
-			});
-			if (options.allowOvertype) inputs.forEach((input) => {
-				input.removeAttribute(ALLOW_OVERTYPE_ATTR);
-			});
-			unregisterValidators(ctx.form);
-			ctx.emit("formie:module:text-limit:destroy", {});
-		} };
-	}
-};
-//#endregion
-export { textLimitModule };

package/dist/chunks/theme-classes-vSHpdCUO.js

@@ -1,59 +0,0 @@
-//#region src/js/theme/theme-classes.ts
-var themeRegistry = /* @__PURE__ */ new WeakMap();
-var THEME_ROOT_SELECTORS = "[data-formie-form], [data-formie], form";
-function splitClasses(value) {
-	if (!value) return [];
-	return (Array.isArray(value) ? value : [value]).flatMap((item) => {
-		return String(item).split(/\s+/);
-	}).map((item) => {
-		return item.trim();
-	}).filter(Boolean);
-}
-function uniqueClasses(classes) {
-	return Array.from(new Set(classes));
-}
-function resolveThemeClassMap(source) {
-	if (!source) return {};
-	const directMatch = themeRegistry.get(source);
-	if (directMatch) return directMatch;
-	const root = source.closest(THEME_ROOT_SELECTORS);
-	if (!root) return {};
-	return themeRegistry.get(root) || {};
-}
-function normalizeThemeClassMap(theme) {
-	const normalized = {};
-	Object.entries(theme || {}).forEach(([key, value]) => {
-		const classes = uniqueClasses(splitClasses(value));
-		if (classes.length) normalized[key] = classes;
-	});
-	return normalized;
-}
-function registerThemeClassMap(target, theme, form) {
-	const normalized = normalizeThemeClassMap(theme);
-	const resolvedForm = form || (target instanceof HTMLFormElement ? target : target.querySelector("form"));
-	themeRegistry.set(target, normalized);
-	if (resolvedForm) themeRegistry.set(resolvedForm, normalized);
-	return normalized;
-}
-function getThemeClasses(source, key) {
-	return resolveThemeClassMap(source)[key] || [];
-}
-function addThemeClasses(target, source, ...keys) {
-	const classes = uniqueClasses(keys.flatMap((key) => {
-		return getThemeClasses(source, key);
-	}));
-	if (classes.length) target.classList.add(...classes);
-}
-function removeThemeClasses(target, source, ...keys) {
-	const classes = uniqueClasses(keys.flatMap((key) => {
-		return getThemeClasses(source, key);
-	}));
-	if (classes.length) target.classList.remove(...classes);
-}
-function toggleThemeClasses(target, source, key, enabled) {
-	getThemeClasses(source, key).forEach((className) => {
-		target.classList.toggle(className, enabled);
-	});
-}
-//#endregion
-export { toggleThemeClasses as i, registerThemeClassMap as n, removeThemeClasses as r, addThemeClasses as t };

package/dist/chunks/turnstile-DP0bdR7T.js

@@ -1,68 +0,0 @@
-import { a as CAPTCHA_PROVIDER_LOAD_TIMEOUT_MS, i as CAPTCHA_EXECUTE_WAIT_FOR_VALUE_MS, o as CAPTCHA_SUBMIT_WAIT_FOR_VALUE_MS, r as getScriptAttributes, t as defineCaptchaModule } from "./api-DOfDzYC_.js";
-import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
-//#region src/js/modules/captchas/turnstile.ts
-function getTurnstileWaitForValueMs(provider) {
-	const appearance = provider.appearance || "always";
-	return (provider.execution || (appearance === "execute" ? "execute" : "render")) === "execute" ? CAPTCHA_EXECUTE_WAIT_FOR_VALUE_MS : CAPTCHA_SUBMIT_WAIT_FOR_VALUE_MS;
-}
-async function loadTurnstileGlobal(options) {
-	const { async, defer } = getScriptAttributes(options.loadingMethod);
-	return loadScriptAndEnsureGlobal("turnstile", {
-		id: "FORMIE_TURNSTILE_SCRIPT",
-		src: "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit",
-		async,
-		defer,
-		timeoutMs: CAPTCHA_PROVIDER_LOAD_TIMEOUT_MS
-	});
-}
-var turnstileModule = defineCaptchaModule({
-	id: "turnstile",
-	defaultPlaceholderSelector: "[data-turnstile-placeholder]",
-	defaultTokenFieldNames: ["cf-turnstile-response"],
-	load: ({ options }) => {
-		return loadTurnstileGlobal(options.provider);
-	},
-	mount: ({ api, container, provider, services }) => {
-		const appearance = provider.appearance || "always";
-		const execution = provider.execution || (appearance === "execute" ? "execute" : "render");
-		return api.render(container, {
-			sitekey: provider.siteKey || "",
-			theme: provider.theme || "auto",
-			size: provider.size || "normal",
-			appearance,
-			execution,
-			callback: (token) => {
-				if (typeof token === "string" && token.trim() !== "") services.tokens.write(token.trim());
-				services.errors.clear();
-			},
-			"expired-callback": () => {
-				services.tokens.clear();
-				services.errors.clear();
-			},
-			"timeout-callback": () => {
-				services.tokens.clear();
-				services.errors.clear();
-			},
-			"error-callback": () => {
-				services.tokens.clear();
-			}
-		});
-	},
-	screen: ({ api, widget, placeholder, services, provider, stageCtx }) => {
-		if (services.tokens.has()) return;
-		api.execute(widget);
-		return services.tokens.wait(getTurnstileWaitForValueMs(provider)).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 { turnstileModule };