@nextlyhq/plugin-form-builder 0.0.2-alpha.68 → 0.0.2-alpha.69

package/dist/field-references-BshlgMcn.js

@@ -0,0 +1,1048 @@
+// src/utils/redirect-reference.ts
+/**
+* The reference a `redirectPage` value holds, in any shape a read produces.
+*
+* Three arrive in practice and they are not interchangeable: a polymorphic
+* field stores `{ relationTo, value }`; a read at depth replaces `value` with
+* the populated row; and a single-target field stores the bare id. The last
+* names no collection, so it resolves only when exactly one is configured —
+* guessing which of several a bare id belongs to would send visitors to a
+* URL built from the wrong collection's pattern.
+*/
+function parseRedirectReference(value, collections) {
+	if (value == null) return null;
+	if (typeof value === "string") {
+		const id = value.trim();
+		return id && collections.length === 1 ? {
+			collection: collections[0],
+			id
+		} : null;
+	}
+	if (typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const relationTo = record.relationTo;
+	const inner = record.value;
+	if (typeof relationTo === "string" && relationTo.trim()) {
+		const id = referenceId(inner);
+		return id ? {
+			collection: relationTo.trim(),
+			id
+		} : null;
+	}
+	const id = referenceId(record);
+	if (!id) return null;
+	return collections.length === 1 ? {
+		collection: collections[0],
+		id
+	} : null;
+}
+function referenceId(value) {
+	if (typeof value === "string") return value.trim() || null;
+	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+		const { id } = value;
+		if (typeof id === "string" && id) return id;
+	}
+	return null;
+}
+/**
+* The field the publish lifecycle puts on every row it manages.
+*
+* A collection without the lifecycle may legally define an ordinary field
+* named `status` — "active", "archived", anything — so the NAME `status` does
+* not identify a lifecycle and reading it as one marks live documents as
+* drafts. This field does identify it: it is written by the framework, not by
+* a schema author.
+*
+* Measured on 2026-08-25, creating one document in each kind of collection:
+* a `status: true` collection returns
+* `[createdAt, firstPublishedAt, id, slug, status, title, updatedAt]`, and a
+* plain collection carrying its own `status` text field returns the same list
+* WITHOUT `firstPublishedAt`. It is present on a never-published draft too, so
+* presence marks the lifecycle rather than the act of publishing.
+*/
+const PUBLISH_LIFECYCLE_FIELD = "firstPublishedAt";
+/**
+* Whether this document comes from a collection with the publish lifecycle.
+*
+* Callers that project their reads must request
+* {@link PUBLISH_LIFECYCLE_FIELD}; a projection that omits it makes every
+* document look unmanaged, which reads as "always reachable".
+*/
+function hasPublishLifecycle(document) {
+	return PUBLISH_LIFECYCLE_FIELD in document;
+}
+/**
+* Whether a visitor can reach this document.
+*
+* `collectionIsLocalized` is the caller's knowledge of the target collection's
+* `localized` setting, or `undefined` where the caller has no way to know.
+*
+* A localized collection publishes PER LOCALE, on a companion row that no read
+* available here returns. Measured on 2026-08-25 against a collection with
+* `localized: true` whose Spanish translation was published while the default
+* locale stayed a draft: `findByID` answers `status: "draft"` at the default
+* locale AND at `es`, and a `find` filtered to `status: "published"` returns
+* the document at no locale at all — no locale, `en` or `es`. So the main
+* row's `status` does not answer for a localized document, and reading it as
+* an answer marks a page visitors can reach as a draft, refuses a correct save
+* and drops a working redirect.
+*
+* `firstPublishedAt` is the one fact that survives that: it records whether the
+* document has ever been public in ANY language, so its absence is decisive
+* whether or not the collection is localized.
+*/
+function documentReachability(document, collectionIsLocalized) {
+	if (!hasPublishLifecycle(document)) return "reachable";
+	if (document.status === "published") return "reachable";
+	if (collectionIsLocalized === false) return "unreachable";
+	return "unknown";
+}
+/**
+* Which settings key names the document this form redirects to, if any.
+*
+* TWO options carry one. "Redirect to a page" stores `redirectPage`, and the
+* URL option falls back to `redirectRelation` when no URL is typed — the shape
+* code-first and legacy forms use, and one the submission path has always
+* resolved. One definition of the question, so the rule that guards a target
+* cannot recognise fewer shapes than the resolver that acts on it: a form the
+* rule skips is a form the resolver still redirects.
+*
+* The two are not equally strict about being EMPTY, deliberately. Naming
+* nothing under "Redirect to a page" contradicts the option itself, so it is
+* reported. Under the URL option an absent relation only means no destination
+* is configured yet — `validateFormConfig` already governs that, and refusing
+* it here would reject saves this rule never governed.
+*/
+function pickedDocumentField(settings) {
+	if (settings.confirmationType === "relationship") return "redirectPage";
+	if (settings.confirmationType === "redirect" && !settings.redirectUrl && settings.redirectRelation != null) return "redirectRelation";
+	return null;
+}
+
+// src/types.ts
+/** Every built-in form field type, as a value list (the single source shared
+* by the field-type guard and the config validator). */
+const BUILT_IN_FORM_FIELD_TYPES = [
+	"text",
+	"email",
+	"number",
+	"phone",
+	"url",
+	"textarea",
+	"select",
+	"checkbox",
+	"radio",
+	"file",
+	"date",
+	"time",
+	"hidden"
+];
+const BUILT_IN_FORM_FIELD_TYPES_SET = new Set(BUILT_IN_FORM_FIELD_TYPES);
+/**
+* Narrow an `AnyFormField` to the closed built-in `FormField` union. Returns
+* `false` for a plugin-contributed field, so callers handle it generically
+* before switching on the built-in discriminant.
+*/
+function isKnownFormField(field) {
+	return BUILT_IN_FORM_FIELD_TYPES_SET.has(field.type);
+}
+/**
+* Check if a value is a FormField.
+*/
+function isFormField(value) {
+	return typeof value === "object" && value !== null && "type" in value && "name" in value && "label" in value;
+}
+/**
+* Check if a FormField is a specific type.
+*/
+function isFormFieldType(field, type) {
+	return field.type === type;
+}
+/**
+* Type guard for text field.
+*/
+function isTextFormField(field) {
+	return field.type === "text";
+}
+/**
+* Type guard for email field.
+*/
+function isEmailFormField(field) {
+	return field.type === "email";
+}
+/**
+* Type guard for select field.
+*/
+function isSelectFormField(field) {
+	return field.type === "select";
+}
+/**
+* Type guard for checkbox field.
+*/
+function isCheckboxFormField(field) {
+	return field.type === "checkbox";
+}
+/**
+* Type guard for file field.
+*/
+function isFileFormField(field) {
+	return field.type === "file";
+}
+
+// src/utils/enforced-validation.ts
+/**
+* `message` appears on every row because it is honoured everywhere: each
+* generator passes `validation.errorMessage` to `applyRequired`, so even a type
+* with no bounds of its own uses it for the required failure.
+*
+* Typed as a total `Record` rather than a partial one, so adding a field type
+* without deciding what it enforces is a compile error instead of a type that
+* silently offers nothing.
+*/
+const ENFORCED_VALIDATION_RULES = {
+	text: [
+		"minLength",
+		"maxLength",
+		"pattern",
+		"message"
+	],
+	email: ["pattern", "message"],
+	number: [
+		"min",
+		"max",
+		"message"
+	],
+	phone: ["pattern", "message"],
+	url: ["pattern", "message"],
+	textarea: [
+		"minLength",
+		"maxLength",
+		"message"
+	],
+	select: ["message"],
+	checkbox: ["message"],
+	radio: ["message"],
+	file: ["message"],
+	date: ["message"],
+	time: ["message"],
+	hidden: ["message"]
+};
+/**
+* The rules a field of this type both accepts and has enforced.
+*
+* A plugin-contributed type has no row, and correctly gets nothing: this
+* runtime's generator has no clause for it, so every rule would be inert.
+*/
+function enforcedValidationRules(type) {
+	return ENFORCED_VALIDATION_RULES[type] ?? [];
+}
+
+// src/config/removed-options.ts
+/** Forms already told, so a config passing through both entry points hears it once. */
+const warned = /* @__PURE__ */ new Set();
+/**
+* Say so when a form config still sets `notifications.webhooks`.
+*
+* The plugin sends no webhooks of its own: a submission reaches other systems
+* through Nextly's `form.submission.created` webhook, so the option sends
+* nothing and the config is told what to use instead.
+*/
+function warnIfWebhooksConfigured(config) {
+	const notifications = config.notifications;
+	if (typeof notifications !== "object" || notifications === null) return;
+	if (!("webhooks" in notifications) || warned.has(config.slug)) return;
+	warned.add(config.slug);
+	console.warn(`[form-builder] Form "${config.slug}" sets notifications.webhooks, which the Form Builder no longer reads, so those webhooks are not sent. Subscribe an endpoint to Nextly's form.submission.created webhook instead: https://nextlyhq.com/docs/plugins/form-builder#webhooks`);
+}
+
+// src/config/defaults.ts
+/**
+* Default form settings.
+*/
+const DEFAULT_FORM_SETTINGS = {
+	submitButtonText: "Submit",
+	confirmationType: "message",
+	successMessage: "Thank you for your submission!",
+	allowMultipleSubmissions: true
+};
+/**
+* Default notification settings.
+*/
+const DEFAULT_NOTIFICATION_SETTINGS = {
+	enabled: true,
+	replyTo: true
+};
+/**
+* Converts a slug to title case.
+*
+* @param str - The slug string to convert
+* @returns Title case string
+*
+* @example
+* ```typescript
+* toTitleCase('contact-form'); // 'Contact Form'
+* toTitleCase('newsletter_signup'); // 'Newsletter Signup'
+* ```
+*/
+function toTitleCase(str) {
+	return str.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+/**
+* Generates a plural form from a singular label.
+* Handles common English pluralization rules.
+*
+* @param singular - The singular form
+* @returns The plural form
+*
+* @example
+* ```typescript
+* pluralize('Form'); // 'Forms'
+* pluralize('Category'); // 'Categories'
+* pluralize('Quiz'); // 'Quizzes'
+* ```
+*/
+function pluralize(singular) {
+	if (singular.endsWith("y") && !/[aeiou]y$/i.test(singular)) return singular.slice(0, -1) + "ies";
+	if (singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") || singular.endsWith("ch") || singular.endsWith("sh")) return singular + "es";
+	return singular + "s";
+}
+/**
+* Apply default values to form configuration.
+*
+* This function takes a partial form configuration and returns a complete
+* configuration with all default values applied. User-specified values
+* are preserved and take precedence over defaults.
+*
+* @param config - Form configuration (may be partial)
+* @returns Configuration with defaults applied
+*
+* @example
+* ```typescript
+* import { applyFormDefaults } from '@nextly/plugin-form-builder';
+*
+* const config = {
+*   slug: 'contact-form',
+*   fields: [
+*     { type: 'text', name: 'name', label: 'Name' },
+*     { type: 'email', name: 'email', label: 'Email' },
+*   ],
+* };
+*
+* const result = applyFormDefaults(config);
+*
+* // Result:
+* // {
+* //   slug: 'contact-form',
+* //   labels: { singular: 'Contact Form', plural: 'Contact Forms' },
+* //   fields: [...],
+* //   settings: {
+* //     submitButtonText: 'Submit',
+* //     confirmationType: 'message',
+* //     successMessage: 'Thank you for your submission!',
+* //     allowMultipleSubmissions: true,
+* //   },
+* //   access: {
+* //     submit: () => true,
+* //     read: ({ req }) => !!req.user,
+* //   },
+* // }
+* ```
+*/
+function applyFormDefaults(config) {
+	warnIfWebhooksConfigured(config);
+	const singularLabel = config.labels?.singular || toTitleCase(config.slug);
+	return {
+		...config,
+		labels: {
+			singular: singularLabel,
+			plural: config.labels?.plural || pluralize(singularLabel)
+		},
+		settings: {
+			submitButtonText: config.settings?.submitButtonText || DEFAULT_FORM_SETTINGS.submitButtonText,
+			confirmationType: config.settings?.confirmationType || DEFAULT_FORM_SETTINGS.confirmationType,
+			successMessage: config.settings?.successMessage || DEFAULT_FORM_SETTINGS.successMessage,
+			allowMultipleSubmissions: config.settings?.allowMultipleSubmissions ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions,
+			redirectUrl: config.settings?.redirectUrl,
+			redirectRelation: config.settings?.redirectRelation,
+			honeypotEnabled: config.settings?.honeypotEnabled,
+			captchaEnabled: config.settings?.captchaEnabled,
+			captchaSiteKey: config.settings?.captchaSiteKey
+		},
+		notifications: config.notifications ? {
+			enabled: config.notifications.enabled ?? DEFAULT_NOTIFICATION_SETTINGS.enabled,
+			recipients: config.notifications.recipients || [],
+			subject: config.notifications.subject || `New submission for ${singularLabel}`,
+			replyTo: config.notifications.replyTo ?? DEFAULT_NOTIFICATION_SETTINGS.replyTo,
+			template: config.notifications.template
+		} : void 0,
+		access: {
+			submit: config.access?.submit || (() => true),
+			read: config.access?.read || (({ req }) => !!req.user)
+		}
+	};
+}
+/**
+* Apply default values to individual form field.
+*
+* This is a utility function for applying defaults to a single field,
+* useful when processing fields individually (e.g., in the Schema Builder).
+*
+* @param field - The field to apply defaults to
+* @returns Field with defaults applied
+*
+* @example
+* ```typescript
+* import { applyFieldDefaults } from '@nextly/plugin-form-builder';
+*
+* const field = { type: 'text', name: 'firstName' };
+* const fieldWithDefaults = applyFieldDefaults(field);
+* // { type: 'text', name: 'firstName', label: 'First Name', required: false }
+* ```
+*/
+function applyFieldDefaults(field) {
+	const label = field.label || (field.name ? toTitleCase(field.name.replace(/([A-Z])/g, " $1").trim()) : "");
+	return {
+		...field,
+		label,
+		required: field.required ?? false
+	};
+}
+/**
+* Creates a complete form config with minimal input.
+*
+* This is a convenience function for quickly creating form configs
+* with sensible defaults. Only the slug and fields are required.
+*
+* @param slug - The form slug
+* @param fields - Array of form fields
+* @param options - Optional additional configuration
+* @returns Complete form configuration
+*
+* @example
+* ```typescript
+* import { createFormConfig } from '@nextly/plugin-form-builder';
+*
+* const config = createFormConfig('contact', [
+*   { type: 'text', name: 'name', label: 'Name', required: true },
+*   { type: 'email', name: 'email', label: 'Email', required: true },
+*   { type: 'textarea', name: 'message', label: 'Message' },
+* ]);
+* ```
+*/
+function createFormConfig(slug, fields, options) {
+	return applyFormDefaults({
+		slug,
+		fields,
+		...options
+	});
+}
+
+// src/utils/form-settings.ts
+/**
+* The ONE reader for stored form settings. Settings were historically
+* written in two shapes (the builder's old context shape and the collection
+* group's declared shape), so every consumer — the builder UI and the
+* submit handler alike — normalizes through here instead of trusting the
+* stored keys.
+*/
+function asOptionalBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function asOptionalString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/**
+* Normalize a stored settings value into the canonical {@link FormSettings}.
+*
+* Legacy keys are migrated on read (no data is lost, nothing is rewritten
+* until the form is next saved):
+* - `confirmationMessage` → `successMessage` + `confirmationType: "message"`
+* - nested `captcha: { enabled, siteKey }` → flat `captchaEnabled`/`captchaSiteKey`
+*
+* Keys with no consumer (`showResetButton`, `resetButtonText`,
+* `storeSubmissions`, `submissionLimit`) are dropped: a setting that does
+* nothing must not survive into the UI.
+*/
+function normalizeFormSettings(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { ...DEFAULT_FORM_SETTINGS };
+	const source = raw;
+	const legacyMessage = asOptionalString(source.confirmationMessage);
+	const legacyCaptcha = source.captcha && typeof source.captcha === "object" ? source.captcha : void 0;
+	const confirmationType = source.confirmationType === "redirect" || source.confirmationType === "relationship" ? source.confirmationType : "message";
+	return {
+		submitButtonText: asOptionalString(source.submitButtonText) ?? DEFAULT_FORM_SETTINGS.submitButtonText,
+		confirmationType,
+		successMessage: asOptionalString(source.successMessage) ?? legacyMessage ?? DEFAULT_FORM_SETTINGS.successMessage,
+		redirectUrl: asOptionalString(source.redirectUrl),
+		redirectPage: source.redirectPage ?? void 0,
+		redirectRelation: source.redirectRelation && typeof source.redirectRelation === "object" ? source.redirectRelation : void 0,
+		allowMultipleSubmissions: asOptionalBoolean(source.allowMultipleSubmissions) ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions,
+		honeypotEnabled: asOptionalBoolean(source.honeypotEnabled),
+		captchaEnabled: asOptionalBoolean(source.captchaEnabled) ?? asOptionalBoolean(legacyCaptcha?.enabled),
+		captchaSiteKey: asOptionalString(source.captchaSiteKey) ?? asOptionalString(legacyCaptcha?.siteKey)
+	};
+}
+
+// src/utils/evaluate-conditions.ts
+/**
+* Checks if a value is considered "empty".
+* Empty values: undefined, null, empty string, empty array.
+*/
+function isEmptyValue(value) {
+	if (value === void 0 || value === null) return true;
+	if (typeof value === "string" && value.trim() === "") return true;
+	if (Array.isArray(value) && value.length === 0) return true;
+	return false;
+}
+/**
+* Converts a value to a number for numeric comparisons.
+* Returns NaN if conversion is not possible.
+*/
+function toNumber(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed === "") return NaN;
+		return Number(trimmed);
+	}
+	return NaN;
+}
+/**
+* Converts a value to a string for string comparisons.
+*/
+function toString(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.join(", ");
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+/**
+* Compares two values using the specified operator.
+*
+* @param operator - The comparison operator to use
+* @param fieldValue - The actual value from the form data
+* @param conditionValue - The expected value from the condition
+* @returns Whether the comparison is true
+*/
+function compareValues(operator, fieldValue, conditionValue) {
+	switch (operator) {
+		case "equals":
+			if (Array.isArray(fieldValue)) {
+				if (Array.isArray(conditionValue)) {
+					if (fieldValue.length !== conditionValue.length) return false;
+					return fieldValue.every((v, i) => v === conditionValue[i]);
+				}
+				return fieldValue.includes(conditionValue);
+			}
+			return toString(fieldValue) === toString(conditionValue);
+		case "notEquals":
+			if (Array.isArray(fieldValue)) {
+				if (Array.isArray(conditionValue)) {
+					if (fieldValue.length !== conditionValue.length) return true;
+					return !fieldValue.every((v, i) => v === conditionValue[i]);
+				}
+				return !fieldValue.includes(conditionValue);
+			}
+			return toString(fieldValue) !== toString(conditionValue);
+		case "contains": {
+			const fieldStr = toString(fieldValue).toLowerCase();
+			const conditionStr = toString(conditionValue).toLowerCase();
+			if (Array.isArray(fieldValue)) return fieldValue.some((v) => toString(v).toLowerCase().includes(conditionStr));
+			return fieldStr.includes(conditionStr);
+		}
+		case "isEmpty": return isEmptyValue(fieldValue);
+		case "isNotEmpty": return !isEmptyValue(fieldValue);
+		case "greaterThan": {
+			const fieldNum = toNumber(fieldValue);
+			const conditionNum = toNumber(conditionValue);
+			if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) return fieldNum > conditionNum;
+			return toString(fieldValue) > toString(conditionValue);
+		}
+		case "lessThan": {
+			const fieldNum = toNumber(fieldValue);
+			const conditionNum = toNumber(conditionValue);
+			if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) return fieldNum < conditionNum;
+			return toString(fieldValue) < toString(conditionValue);
+		}
+		default:
+			console.warn(`[evaluateConditions] Unknown comparison operator: ${String(operator)}`);
+			return false;
+	}
+}
+/**
+* Evaluates a single condition against the form data.
+*
+* Exported for consumers that gate on one condition rather than a full
+* conditional-logic block — notification send-conditions use exactly this.
+*
+* @param condition - The condition to evaluate
+* @param formData - The current form data
+* @returns Whether the condition is met
+*/
+function evaluateSingleCondition(condition, formData) {
+	const { field, comparison, value: conditionValue } = condition;
+	return compareValues(comparison, getNestedValue(formData, field), conditionValue);
+}
+/**
+* Gets a nested value from an object using dot notation.
+*
+* @param obj - The object to get the value from
+* @param path - The path to the value (e.g., "address.city")
+* @returns The value at the path, or undefined if not found
+*/
+function getNestedValue(obj, path) {
+	if (!path) return;
+	if (!path.includes(".")) return obj[path];
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === void 0 || current === null) return;
+		if (typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
+}
+/**
+* Evaluates conditional logic to determine field visibility.
+*
+* This is the main entry point for conditional logic evaluation.
+* It evaluates all conditions according to the logical operator (AND/OR)
+* and returns whether the field should be visible based on the action
+* (show/hide).
+*
+* @param logic - The conditional logic configuration
+* @param formData - The current form data (field values)
+* @returns Whether the field should be visible
+*
+* @example
+* ```typescript
+* // Show field when country is US AND age is over 18
+* const logic: ConditionalLogic = {
+*   enabled: true,
+*   action: 'show',
+*   operator: 'AND',
+*   conditions: [
+*     { field: 'country', comparison: 'equals', value: 'US' },
+*     { field: 'age', comparison: 'greaterThan', value: 18 },
+*   ],
+* };
+*
+* evaluateConditions(logic, { country: 'US', age: 25 }); // true
+* evaluateConditions(logic, { country: 'US', age: 15 }); // false
+* evaluateConditions(logic, { country: 'CA', age: 25 }); // false
+*
+* // Hide field when status is "completed"
+* const hideLogic: ConditionalLogic = {
+*   enabled: true,
+*   action: 'hide',
+*   operator: 'AND',
+*   conditions: [
+*     { field: 'status', comparison: 'equals', value: 'completed' },
+*   ],
+* };
+*
+* evaluateConditions(hideLogic, { status: 'completed' }); // false (hidden)
+* evaluateConditions(hideLogic, { status: 'pending' });   // true (visible)
+* ```
+*
+* @example
+* ```typescript
+* // Show field when either condition is met (OR)
+* const orLogic: ConditionalLogic = {
+*   enabled: true,
+*   action: 'show',
+*   operator: 'OR',
+*   conditions: [
+*     { field: 'role', comparison: 'equals', value: 'admin' },
+*     { field: 'role', comparison: 'equals', value: 'editor' },
+*   ],
+* };
+*
+* evaluateConditions(orLogic, { role: 'admin' });  // true
+* evaluateConditions(orLogic, { role: 'editor' }); // true
+* evaluateConditions(orLogic, { role: 'viewer' }); // false
+* ```
+*/
+function evaluateConditions(logic, formData) {
+	if (!logic || !logic.enabled) return true;
+	const { action, operator, conditions } = logic;
+	if (!conditions || conditions.length === 0) return true;
+	const results = conditions.map((condition) => evaluateSingleCondition(condition, formData));
+	let conditionsMet;
+	if (operator === "OR") conditionsMet = results.some((result) => result);
+	else conditionsMet = results.every((result) => result);
+	if (action === "hide") return !conditionsMet;
+	return conditionsMet;
+}
+/**
+* Checks if a comparison operator is valid.
+*
+* @param operator - The operator to check
+* @returns Whether the operator is valid
+*/
+function isValidComparisonOperator(operator) {
+	return [
+		"equals",
+		"notEquals",
+		"contains",
+		"isEmpty",
+		"isNotEmpty",
+		"greaterThan",
+		"lessThan"
+	].includes(operator);
+}
+/**
+* Gets the list of supported comparison operators.
+*
+* @returns Array of supported operator names
+*/
+function getSupportedComparisonOperators() {
+	return [
+		"equals",
+		"notEquals",
+		"contains",
+		"isEmpty",
+		"isNotEmpty",
+		"greaterThan",
+		"lessThan"
+	];
+}
+
+// src/utils/export-formats.ts
+/** UTF-8 BOM character sequence */
+const UTF8_BOM = "";
+/**
+* Stringify a value safely, falling back to JSON for plain objects so we
+* never emit the default `[object Object]` representation.
+*/
+function safeString(value) {
+	if (typeof value === "object" && value !== null) return JSON.stringify(value);
+	return String(value);
+}
+/**
+* Format a field value for export based on field type.
+*
+* @param value - The raw value from submission data
+* @param field - The field definition (optional, for type-specific formatting)
+* @returns Formatted string representation of the value
+*
+* @example
+* ```typescript
+* formatExportValue(true, { type: 'checkbox' }); // "Yes"
+* formatExportValue(['a', 'b'], { type: 'select' }); // "a, b"
+* formatExportValue(new Date(), { type: 'date' }); // "2024-01-15"
+* ```
+*/
+function formatExportValue(value, field) {
+	if (value === null || value === void 0) return "";
+	if (field) switch (field.type) {
+		case "checkbox": return value ? "Yes" : "No";
+		case "select":
+			if (Array.isArray(value)) return value.join(", ");
+			return safeString(value);
+		case "file":
+			if (Array.isArray(value)) return value.map((v) => safeString(v)).join(", ");
+			return safeString(value);
+		case "date":
+			if (value instanceof Date) return value.toISOString().split("T")[0];
+			if (typeof value === "string") {
+				const parsed = new Date(value);
+				if (!isNaN(parsed.getTime())) return parsed.toISOString().split("T")[0];
+			}
+			return safeString(value);
+		case "time": return safeString(value);
+		case "hidden": return safeString(value);
+	}
+	if (Array.isArray(value)) return value.join(", ");
+	if (typeof value === "boolean") return value ? "Yes" : "No";
+	if (value instanceof Date) return value.toISOString();
+	return safeString(value);
+}
+/**
+* Format a date for export.
+*
+* @param date - Date value (Date object or string)
+* @param format - Output format ("iso" or "locale")
+* @returns Formatted date string
+*/
+function formatDate(date, format = "iso") {
+	if (!date) return "";
+	const d = typeof date === "string" ? new Date(date) : date;
+	if (isNaN(d.getTime())) return "";
+	return format === "iso" ? d.toISOString() : d.toLocaleString();
+}
+/**
+* Escape a value for CSV format (RFC 4180 compliant).
+*
+* Rules:
+* - Fields containing comma, double-quote, or newline must be quoted
+* - Double-quotes within fields must be escaped with another double-quote
+*
+* @param value - The value to escape
+* @param delimiter - The delimiter being used
+* @returns Properly escaped CSV value
+*/
+function escapeCSVValue(value, delimiter = ",") {
+	const escapedFormula = /^[=+\-@\t\r]/.test(value) && !/^-?\d+(\.\d+)?$/.test(value) ? `'${value}` : value;
+	if (!(escapedFormula.includes(delimiter) || escapedFormula.includes("\"") || escapedFormula.includes("\n") || escapedFormula.includes("\r"))) return escapedFormula;
+	return `"${escapedFormula.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Export submissions to CSV format.
+*
+* Generates an RFC 4180 compliant CSV string with:
+* - Form field values as columns (in form definition order)
+* - Optional metadata columns at the end (_id, _status, _submittedAt, etc.)
+* - Proper escaping of special characters
+* - Optional UTF-8 BOM for Excel compatibility
+*
+* @param submissions - Array of submission documents to export
+* @param form - Form document containing field definitions
+* @param options - Export options
+* @returns CSV formatted string
+*
+* @example
+* ```typescript
+* const csv = exportToCSV(submissions, form, {
+*   includeMetadata: true,
+*   includeBOM: true,
+* });
+*
+* // Download in browser
+* downloadFile(csv, 'submissions.csv', 'text/csv;charset=utf-8');
+* ```
+*/
+function exportToCSV(submissions, form, options = {}) {
+	const { includeMetadata = true, delimiter = ",", includeBOM = true, dateFormat = "iso" } = options;
+	const exportableFields = form.fields;
+	const headers = [];
+	for (const field of exportableFields) headers.push(field.label);
+	if (includeMetadata) headers.push("ID", "Status", "Submitted At", "IP Address", "User Agent");
+	const rows = [];
+	for (const submission of submissions) {
+		const row = [];
+		const data = submission.data;
+		for (const field of exportableFields) {
+			const value = data[field.name];
+			const formatted = formatExportValue(value, field);
+			row.push(escapeCSVValue(formatted, delimiter));
+		}
+		if (includeMetadata) {
+			row.push(escapeCSVValue(submission.id, delimiter));
+			row.push(escapeCSVValue(submission.status, delimiter));
+			row.push(escapeCSVValue(formatDate(submission.submittedAt, dateFormat), delimiter));
+			row.push(escapeCSVValue(submission.ipAddress || "", delimiter));
+			row.push(escapeCSVValue(submission.userAgent || "", delimiter));
+		}
+		rows.push(row);
+	}
+	const csvContent = [headers.map((h) => escapeCSVValue(h, delimiter)).join(delimiter), ...rows.map((row) => row.join(delimiter))].join("\r\n");
+	return includeBOM ? UTF8_BOM + csvContent : csvContent;
+}
+/**
+* Export submissions to JSON format.
+*
+* Generates a structured JSON export with:
+* - Export metadata (timestamp)
+* - Optional form definition
+* - Array of submissions with field values
+* - Optional submission metadata (_id, _status, etc.)
+*
+* @param submissions - Array of submission documents to export
+* @param form - Form document containing field definitions
+* @param options - Export options
+* @returns JSON formatted string
+*
+* @example
+* ```typescript
+* const json = exportToJSON(submissions, form, {
+*   includeMetadata: true,
+*   includeFormDefinition: true,
+*   indent: 2,
+* });
+*
+* // Download in browser
+* downloadFile(json, 'submissions.json', 'application/json');
+* ```
+*/
+function exportToJSON(submissions, form, options = {}) {
+	const { includeMetadata = true, includeFormDefinition = true, indent = 2 } = options;
+	const exportableFields = form.fields;
+	const formDefinition = includeFormDefinition ? {
+		id: form.id,
+		name: form.name,
+		slug: form.slug,
+		fields: exportableFields.map((f) => ({
+			name: f.name,
+			label: f.label,
+			type: f.type
+		}))
+	} : void 0;
+	const exportedSubmissions = submissions.map((submission) => {
+		const data = submission.data;
+		const fieldData = {};
+		for (const field of exportableFields) {
+			const value = data[field.name];
+			fieldData[field.name] = value;
+		}
+		if (includeMetadata) return {
+			...fieldData,
+			_metadata: {
+				id: submission.id,
+				status: submission.status,
+				submittedAt: submission.submittedAt,
+				ipAddress: submission.ipAddress || null,
+				userAgent: submission.userAgent || null,
+				createdAt: submission.createdAt,
+				updatedAt: submission.updatedAt
+			}
+		};
+		return fieldData;
+	});
+	const exportData = {
+		exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		totalSubmissions: submissions.length,
+		submissions: exportedSubmissions
+	};
+	if (formDefinition) exportData.form = formDefinition;
+	return JSON.stringify(exportData, null, indent);
+}
+/**
+* Trigger a file download in the browser.
+*
+* Creates a Blob from the content and triggers a download using a temporary
+* anchor element. This function is browser-only and will throw in Node.js.
+*
+* @param content - File content as string
+* @param filename - Name for the downloaded file
+* @param mimeType - MIME type of the file
+*
+* @example
+* ```typescript
+* const csv = exportToCSV(submissions, form);
+* downloadFile(csv, 'contact-form-submissions.csv', 'text/csv;charset=utf-8');
+*
+* const json = exportToJSON(submissions, form);
+* downloadFile(json, 'submissions.json', 'application/json');
+* ```
+*/
+function downloadFile(content, filename, mimeType) {
+	if (typeof window === "undefined" || typeof document === "undefined") throw new Error("downloadFile is only available in browser environments");
+	const blob = new Blob([content], { type: mimeType });
+	const url = URL.createObjectURL(blob);
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = filename;
+	document.body.appendChild(link);
+	link.click();
+	document.body.removeChild(link);
+	URL.revokeObjectURL(url);
+}
+/**
+* Generate a filename for export.
+*
+* Creates a filename with form slug and current timestamp.
+*
+* @param formSlug - The form's slug
+* @param format - Export format ('csv' or 'json')
+* @returns Generated filename
+*
+* @example
+* ```typescript
+* generateExportFilename('contact-form', 'csv');
+* // Returns: "contact-form-submissions-2024-01-15.csv"
+* ```
+*/
+function generateExportFilename(formSlug, format) {
+	return `${formSlug.toLowerCase().replace(/[^a-z0-9_-]+/g, "-") || "form"}-submissions-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${format}`;
+}
+/**
+* Export submissions and trigger browser download.
+*
+* Convenience function that combines export and download in one call.
+* Browser-only.
+*
+* @param submissions - Array of submission documents
+* @param form - Form document
+* @param format - Export format ('csv' or 'json')
+* @param options - Format-specific options
+*
+* @example
+* ```typescript
+* // In a React component
+* const handleExport = (format: 'csv' | 'json') => {
+*   exportAndDownload(submissions, form, format);
+* };
+* ```
+*/
+function exportAndDownload(submissions, form, format, options) {
+	const filename = generateExportFilename(form.slug, format);
+	if (format === "csv") downloadFile(exportToCSV(submissions, form, options), filename, "text/csv;charset=utf-8");
+	else downloadFile(exportToJSON(submissions, form, options), filename, "application/json");
+}
+
+// src/utils/field-references.ts
+/**
+* The one spelling of a field reference this plugin recognises: `{{fieldName}}`
+* with no spaces, and `\w` names.
+*
+* Exact, because the SEND path is exact — a value the admin accepts as a
+* reference and the send path does not is delivered with its braces intact,
+* straight to the mail provider. Both sides read this constant so the question
+* has one answer.
+*/
+const FIELD_REF_PATTERN = /^\{\{(\w+)\}\}$/;
+/** The field named by a reference, or `null` when the value is not one. */
+function parseFieldRef(value) {
+	if (!value) return null;
+	const match = value.match(FIELD_REF_PATTERN);
+	return match ? match[1] : null;
+}
+/**
+* Match `{{ fieldName }}` interpolations (whitespace-tolerant), the syntax the
+* notification send path resolves recipients and reply-to values with.
+*/
+function referencesInTemplate(template, fieldName) {
+	return new RegExp(`\\{\\{\\s*${fieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\}\\}`).test(template);
+}
+/** All references to `fieldName` across the form's fields and notifications. */
+function findFieldReferences(fieldName, fields, notifications) {
+	const references = [];
+	for (const field of fields) {
+		if (field.name === fieldName) continue;
+		if (!field.conditionalLogic?.enabled) continue;
+		if ((field.conditionalLogic.conditions ?? []).some((condition) => condition.field === fieldName)) references.push({
+			kind: "condition",
+			label: field.label || field.name
+		});
+	}
+	for (const notification of notifications) {
+		if (!notification.enabled) continue;
+		const referencedByTemplate = [
+			notification.to,
+			...notification.cc ?? [],
+			...notification.bcc ?? [],
+			notification.replyTo
+		].filter((value) => typeof value === "string").some((template) => referencesInTemplate(template, fieldName));
+		const referencedByCondition = notification.condition?.field === fieldName;
+		if (referencedByTemplate || referencedByCondition) references.push({
+			kind: "notification",
+			label: notification.name || "Notification"
+		});
+	}
+	return references;
+}
+/**
+* Reference lists for every field in one pass, keyed by field name, so a
+* per-card lookup is O(1) instead of re-walking fields and notifications for
+* each card on every render.
+*/
+function buildFieldReferenceMap(fields, notifications) {
+	const map = /* @__PURE__ */ new Map();
+	for (const field of fields) map.set(field.name, findFieldReferences(field.name, fields, notifications));
+	return map;
+}
+
+export { isKnownFormField as A, enforcedValidationRules as C, isFileFormField as D, isEmailFormField as E, pickedDocumentField as F, isTextFormField as M, documentReachability as N, isFormField as O, parseRedirectReference as P, ENFORCED_VALIDATION_RULES as S, isCheckboxFormField as T, applyFormDefaults as _, exportToCSV as a, toTitleCase as b, generateExportFilename as c, getSupportedComparisonOperators as d, isValidComparisonOperator as f, applyFieldDefaults as g, DEFAULT_NOTIFICATION_SETTINGS as h, exportAndDownload as i, isSelectFormField as j, isFormFieldType as k, evaluateConditions as l, DEFAULT_FORM_SETTINGS as m, parseFieldRef as n, exportToJSON as o, normalizeFormSettings as p, downloadFile as r, formatExportValue as s, buildFieldReferenceMap as t, evaluateSingleCondition as u, createFormConfig as v, BUILT_IN_FORM_FIELD_TYPES as w, warnIfWebhooksConfigured as x, pluralize as y };
+//# sourceMappingURL=field-references-BshlgMcn.js.map