@nextlyhq/plugin-form-builder 0.0.2-alpha.74 → 0.0.2-alpha.76

package/dist/field-references-CtzGg51W.js

@@ -1,1318 +0,0 @@
-// 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/utils/schema-only-read.ts
-/**
-* The hook context that tells the forms collection's `afterRead` hook a read
-* wants the forms themselves and nothing only a display needs, so it skips
-* the submission count it would otherwise run per form: a write checking a
-* submission against its form, and the dashboard card scanning which forms a
-* reader may read, need the count no more than they need a second copy of
-* the form.
-*
-* @module utils/schema-only-read
-*/
-/** The context key the forms `afterRead` hook reads; `true` skips the count. */
-const SCHEMA_ONLY_READ = "formBuilder.schemaOnlyRead";
-/** The context a schema-only read hands the forms collection's hooks. */
-const SCHEMA_ONLY_CONTEXT = { [SCHEMA_ONLY_READ]: true };
-
-// src/dashboard/new-submissions.ts
-/** The widget's id, the one core's default names. */
-const NEW_SUBMISSIONS_WIDGET_ID = "form-builder/new-submissions";
-/** The status a submission arrives with, and keeps until someone opens it. */
-const NEW_STATUS = "new";
-/** The admin's root, which a row's link and the list's link start from. */
-const ADMIN_ROOT = "/admin";
-/** The most forms one read answers, the widget reads' own cap. */
-const FORM_PAGE = 50;
-/**
-* The most pages of forms read for the filter: 1,000 forms. Past that, the
-* later forms' submissions are left out of the card and the count, never
-* shown: what is missed is a reader's own, not someone else's. The count then
-* says it is a floor (`atLeast`), so nobody reads it as every one.
-*/
-const MAX_FORM_PAGES = 20;
-/** The submission fields a row is made from; no other is asked for. */
-const SUBMISSION_FIELDS = [
-	"id",
-	"form",
-	"data",
-	"submittedAt",
-	"createdAt"
-];
-/** The form fields a row is made from. */
-const FORM_FIELDS = [
-	"id",
-	"name",
-	"fields"
-];
-/**
-* Field names and labels that mark a form's name field, compared as letters
-* only (`lettersOf`), so case, spaces, underscores, hyphens and camelCase do
-* not matter: `firstName`, `first_name` and "First name" are all "firstname".
-*/
-const NAME_KEYS = /* @__PURE__ */ new Set([
-	"name",
-	"fullname",
-	"firstname",
-	"yourname",
-	"yourfullname",
-	"yourfirstname"
-]);
-/**
-* The most characters of an answer or a name a row carries. A form may leave
-* a field's length open, so a visitor's answer can be any length; the card
-* draws one line, and the rest would only weigh down its data and the page.
-*/
-const MAX_ROW_TEXT = 140;
-/** The answer types whose first line a row may show under its title. */
-const TEXT_TYPES = /* @__PURE__ */ new Set(["text", "textarea"]);
-/** Up to `limit` ids of forms the reader may read, by id, after `after`. */
-async function formIdPage(services, forms, page) {
-	const { items } = await services.find(forms, {
-		...page.after === void 0 ? {} : { where: { id: { greater_than: page.after } } },
-		sort: "id",
-		limit: page.limit,
-		select: ["id"],
-		status: "all",
-		context: SCHEMA_ONLY_CONTEXT,
-		...page.signal === void 0 ? {} : { signal: page.signal }
-	});
-	return items.flatMap((item) => typeof item.id === "string" ? [item.id] : []);
-}
-/**
-* The ids of the forms the reader may read, in pages of `FORM_PAGE`, by id,
-* at most `MAX_FORM_PAGES` of them. A form a read rule keeps from them is
-* never among them. Where the budget is spent, one more id says whether any
-* form was left out.
-*/
-async function readableFormIds(services, forms, signal) {
-	const ids = [];
-	let after;
-	for (let page = 0; page < MAX_FORM_PAGES; page += 1) {
-		const pageIds = await formIdPage(services, forms, {
-			after,
-			limit: FORM_PAGE,
-			signal
-		});
-		ids.push(...pageIds);
-		after = pageIds.at(-1);
-		if (pageIds.length < FORM_PAGE) return {
-			ids,
-			complete: true
-		};
-	}
-	return {
-		ids,
-		complete: (await formIdPage(services, forms, {
-			after,
-			limit: 1,
-			signal
-		})).length === 0
-	};
-}
-/**
-* The forms the reader may read, scanned once in `scope` where one is given:
-* the card's data and the header's count, answered in one request, share one
-* scan. Keyed by the forms collection, so a site that renamed it scans its own.
-*/
-function readableFormsOnce(services, forms, read) {
-	const scan = () => readableFormIds(services, forms, read.signal);
-	return read.scope === void 0 ? scan() : read.scope.getOrCompute(`readable-forms:${forms}`, scan);
-}
-/** The new submissions of the forms named: what the card lists and the header counts. */
-function newSubmissionsWhere(formIds) {
-	return {
-		status: { equals: "new" },
-		form: { in: [...formIds] }
-	};
-}
-/**
-* The card's data: the newest new submissions the card holds, and how many
-* there are. Asked with a `limit` of 0 it reads no rows and still counts
-* them, which is the header's count.
-*/
-async function readNewSubmissions(services, collections, read) {
-	const signal = read.signal === void 0 ? {} : { signal: read.signal };
-	const allHref = `${ADMIN_ROOT}/collections/${read.submissionsPath}`;
-	const collection = read.submissionsPath;
-	const readable = await readableFormsOnce(services, collections.forms, read);
-	if (readable.ids.length === 0) return {
-		items: [],
-		total: 0,
-		allHref,
-		collection
-	};
-	const found = await services.find(collections.submissions, {
-		where: newSubmissionsWhere(readable.ids),
-		sort: "-submittedAt",
-		limit: read.limit,
-		select: SUBMISSION_FIELDS,
-		status: "all",
-		total: true,
-		depth: 0,
-		...signal
-	});
-	const forms = await formsOf(services, collections.forms, found.items, signal);
-	return {
-		items: found.items.map((item) => submissionRow(item, forms.get(formIdOf(item.form) ?? ""), allHref)),
-		total: found.total ?? found.items.length,
-		...found.atLeast === true || !readable.complete ? { atLeast: true } : {},
-		allHref,
-		collection
-	};
-}
-/** The forms of the submissions drawn, by id: one read, of those forms only. */
-async function formsOf(services, forms, submissions, signal) {
-	const ids = [...new Set(submissions.flatMap((row) => formIdOf(row.form) ?? []))];
-	if (ids.length === 0) return /* @__PURE__ */ new Map();
-	const { items } = await services.find(forms, {
-		where: { id: { in: ids } },
-		limit: ids.length,
-		select: FORM_FIELDS,
-		status: "all",
-		context: SCHEMA_ONLY_CONTEXT,
-		...signal
-	});
-	return new Map(items.flatMap((item) => typeof item.id === "string" ? [[item.id, item]] : []));
-}
-/**
-* One submission as its row: who sent it, which form and what it opens with,
-* and when. `form` is absent where the reader may not read it, and every value
-* comes from a field the read answered, so a field kept from the reader is a
-* part of the row left out, never guessed.
-*/
-function submissionRow(submission, form, allHref) {
-	const id = typeof submission.id === "string" ? submission.id : "";
-	const answers = recordOf(submission.data);
-	const fields = fieldsOf(form?.fields);
-	const titleField = [fields.find(isNameField), fields.find((field) => field.type === "email")].find((field) => field !== void 0 && firstLine(answers[field.name]) !== void 0);
-	const title = titleField === void 0 ? void 0 : firstLine(answers[titleField.name]);
-	const excerpt = fields.filter((field) => TEXT_TYPES.has(field.type) && field !== titleField).map((field) => firstLine(answers[field.name])).find((line) => line !== void 0);
-	const formName = firstLine(form?.name);
-	const at = instantOf(submission.submittedAt) ?? instantOf(submission.createdAt);
-	return {
-		id,
-		title: title ?? "Submission",
-		...formName === void 0 ? {} : { form: formName },
-		...excerpt === void 0 ? {} : { excerpt },
-		...at === void 0 ? {} : { at },
-		href: `${allHref}/${encodeURIComponent(id)}`
-	};
-}
-/** Whether a form field asks for the submitter's name, by its name or its label. */
-function isNameField(field) {
-	return field.type === "text" && (NAME_KEYS.has(lettersOf(field.name)) || NAME_KEYS.has(lettersOf(field.label ?? "")));
-}
-/** A name or label as its letters alone, lower case: "Full name" is "fullname". */
-function lettersOf(text) {
-	return text.toLowerCase().replace(/[^a-z]/g, "");
-}
-/**
-* The first line of a text answer, trimmed and held to `MAX_ROW_TEXT`
-* characters, or `undefined` for none.
-*/
-function firstLine(value) {
-	if (typeof value !== "string") return void 0;
-	const line = value.split(/\r?\n/).map((part) => part.trim()).find((part) => part !== "");
-	return line === void 0 ? void 0 : clipped(line);
-}
-/**
-* `text` cut to its first `MAX_ROW_TEXT` characters with an ellipsis, where it
-* is longer. Counted in whole characters, so an emoji is never split in two.
-*/
-function clipped(text) {
-	const characters = Array.from(text);
-	if (characters.length <= MAX_ROW_TEXT) return text;
-	return `${characters.slice(0, MAX_ROW_TEXT).join("").trimEnd()}…`;
-}
-/** A relationship's id, whether the read answered the id or the related row. */
-function formIdOf(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "object" && value !== null && "id" in value) {
-		const { id } = value;
-		return typeof id === "string" ? id : void 0;
-	}
-}
-/** A JSON column's value, which some dialects answer as its text. */
-function parsedJson(value) {
-	if (typeof value !== "string") return value;
-	try {
-		return JSON.parse(value);
-	} catch {
-		return;
-	}
-}
-/** A submission's answers, by field name. */
-function recordOf(value) {
-	const parsed = parsedJson(value);
-	return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
-}
-/** A form's fields, as far as a row reads them; any other entry is skipped. */
-function fieldsOf(value) {
-	const parsed = parsedJson(value);
-	if (!Array.isArray(parsed)) return [];
-	return parsed.flatMap((entry) => {
-		if (typeof entry !== "object" || entry === null) return [];
-		const { type, name, label } = entry;
-		if (typeof type !== "string" || typeof name !== "string") return [];
-		return [{
-			type,
-			name,
-			...typeof label === "string" ? { label } : {}
-		}];
-	});
-}
-/** A date as an ISO string, or `undefined` when it is not one. */
-function instantOf(value) {
-	if (typeof value !== "string" && typeof value !== "number") return void 0;
-	const at = new Date(value);
-	return Number.isNaN(at.getTime()) ? void 0 : at.toISOString();
-}
-
-// 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, SCHEMA_ONLY_CONTEXT as F, SCHEMA_ONLY_READ as I, documentReachability as L, isTextFormField as M, NEW_SUBMISSIONS_WIDGET_ID as N, isFormField as O, readNewSubmissions as P, parseRedirectReference as R, 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, pickedDocumentField as z };
-//# sourceMappingURL=field-references-CtzGg51W.js.map