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

package/dist/{field-references-oCuFEwkr.js → submission-title-CVixn15Z.js}

@@ -677,6 +677,238 @@ function getSupportedComparisonOperators() {
 	];
 }
 
+// src/utils/condition-visibility.ts
+/** The names a field's enabled condition reads; none when it has none. */
+function namesRead(field) {
+	const logic = field.conditionalLogic;
+	return logic?.enabled === true ? logic.conditions.map((condition) => condition.field) : [];
+}
+/**
+* Which of a form's fields its conditions hide, for a given set of answers.
+*
+* A condition reads the answers of fields that are themselves shown, so a
+* hidden field's leftover answer never decides another field, and it may read
+* a field before or after its own. Fields are decided in the order their
+* conditions depend on each other, whatever their order on the form.
+*
+* Conditions can read each other in a loop (A shown when B is answered, B
+* shown when A is), and no order settles a loop. The rule for one: fields in
+* the same loop read each other's answers as given, and only the loop's
+* fields decide it, so an unrelated field elsewhere on the form never changes
+* the outcome.
+*
+* A field of type `hidden` is not one of them: it is sent with every
+* submission, unseen.
+*/
+function fieldsHiddenByCondition(fields, answers) {
+	const byName = new Map(fields.map((field) => [field.name, field]));
+	const reach = /* @__PURE__ */ new Map();
+	/** Every field `name`'s condition depends on, directly or through others. */
+	const dependsOn = (name) => {
+		const known = reach.get(name);
+		if (known) return known;
+		const found = /* @__PURE__ */ new Set();
+		reach.set(name, found);
+		const pending = [name];
+		for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+			const field = byName.get(next);
+			for (const read of field ? namesRead(field) : []) if (!found.has(read)) {
+				found.add(read);
+				pending.push(read);
+			}
+		}
+		return found;
+	};
+	const shown = /* @__PURE__ */ new Map();
+	/** Whether field `name` is on the page, deciding what it reads first. */
+	const isShown = (name) => {
+		const decided = shown.get(name);
+		if (decided !== void 0) return decided;
+		const field = byName.get(name);
+		const logic = field?.conditionalLogic;
+		if (!field || logic?.enabled !== true) return true;
+		const read = Object.fromEntries(Object.entries(answers).filter(([other]) => !byName.has(other) || !namesRead(field).includes(other) || dependsOn(other).has(name) || isShown(other)));
+		const result = evaluateConditions(logic, read);
+		shown.set(name, result);
+		return result;
+	};
+	return new Set(fields.filter((field) => !isShown(field.name)).map((field) => field.name));
+}
+
+// src/utils/asked-fields.ts
+/** A stored option value or label as text: a string or a number. */
+function textOf(value) {
+	if (typeof value === "string") return value;
+	return typeof value === "number" ? String(value) : "";
+}
+/** One form field as a submission keeps it. */
+function askedField(field) {
+	const options = field.options;
+	return {
+		name: field.name,
+		label: field.label || field.name,
+		type: field.type,
+		...Array.isArray(options) ? { options: options.map((option) => {
+			const { value, label } = option;
+			const text = textOf(value);
+			return {
+				value: text,
+				label: textOf(label) || text
+			};
+		}) } : {}
+	};
+}
+/** What a new submission with `data` was asked, from its form's fields. */
+function askedSnapshotOf(fields, data) {
+	const hidden = fieldsHiddenByCondition([...fields], data);
+	return {
+		fields: fields.map(askedField),
+		hidden: fields.map((field) => field.name).filter((name) => hidden.has(name))
+	};
+}
+/** A stored snapshot, read: as written, or a JSON string of it. */
+function readAskedSnapshot(value) {
+	let parsed = value;
+	if (typeof parsed === "string") try {
+		parsed = JSON.parse(parsed);
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object") return void 0;
+	const { fields, hidden } = parsed;
+	if (!Array.isArray(fields)) return void 0;
+	return {
+		fields: fields.filter((field) => !!field && typeof field.name === "string" && typeof field.label === "string" && typeof field.type === "string"),
+		hidden: Array.isArray(hidden) ? hidden.filter((name) => typeof name === "string") : []
+	};
+}
+/**
+* The snapshot after staff edit answers. An answer that changed is read with
+* the field as it was when edited to, so an edit to an option added later
+* keeps that option's label; every other field stays as the visitor was
+* asked it. A submission with no snapshot keeps none.
+*/
+function askedAfterEdit(stored, fields, before, after) {
+	if (stored === void 0) return void 0;
+	const changed = new Set(fields.map((field) => field.name).filter((name) => JSON.stringify(before[name]) !== JSON.stringify(after[name])));
+	if (changed.size === 0) return stored;
+	const current = new Map(fields.map((field) => [field.name, field]));
+	const kept = stored.fields.map((field) => changed.has(field.name) && current.has(field.name) ? askedField(current.get(field.name)) : field);
+	for (const name of changed) if (!kept.some((field) => field.name === name) && current.has(name)) kept.push(askedField(current.get(name)));
+	return {
+		fields: kept,
+		hidden: stored.hidden.filter((name) => !changed.has(name))
+	};
+}
+/**
+* The fields a submission's page reads its answers with: as it was asked, or
+* the form as it is now for one stored before submissions kept that.
+*/
+function askedFieldsOf(stored, formFields, data) {
+	return readAskedSnapshot(stored) ?? askedSnapshotOf(formFields, data);
+}
+
+// src/utils/consent.ts
+/** Said when an edit of a submission would change a consent. */
+const CONSENT_EDIT_REFUSED = "A consent cannot be edited: it keeps what the visitor agreed to";
+/** Whether a value is a stored consent answer. */
+function isConsentAnswer(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const answer = value;
+	return typeof answer.agreed === "boolean" && typeof answer.text === "string";
+}
+/**
+* Whether the visitor agreed. Only an explicit yes counts: a box sends `on`,
+* a script `true`; anything else, a stray string included, is not consent.
+*/
+function agreedIn(value) {
+	if (value === true) return true;
+	if (typeof value === "string") return value === "true" || value === "1" || value === "on";
+	if (isConsentAnswer(value)) return value.agreed;
+	return false;
+}
+/**
+* The answer to store for what the visitor sent. The text is the form's, so a
+* visitor who posts an answer object with a text of their own still stores
+* the text the form shows.
+*/
+function consentAnswerOf(value, field) {
+	return {
+		agreed: agreedIn(value),
+		text: field.agreementText
+	};
+}
+function sameConsent(before, after) {
+	if (before === void 0) return after === void 0;
+	if (isConsentAnswer(before)) return isConsentAnswer(after) && before.agreed === after.agreed && before.text === after.text;
+	return JSON.stringify(before) === JSON.stringify(after);
+}
+/**
+* The answers of a stored submission that are consents: each consent field
+* of the form, and any answer stored as a consent, whatever field now has
+* its name. Read from the submission as well as the form, since a form can
+* lose its consent field, or give its name to another field, while its
+* submissions keep what was agreed to.
+*/
+function storedConsentNames(fields, stored) {
+	const names = new Set(fields.filter((field) => field.type === "consent").map((field) => field.name));
+	for (const [name, value] of Object.entries(stored)) if (isConsentAnswer(value)) names.add(name);
+	return [...names];
+}
+/**
+* The consents whose stored answer an edit would change: the edit's answers
+* against the stored ones, for each consent the submission holds. One left
+* out of the edit is a change too, since it would drop the answer.
+*/
+function editedConsents(fields, stored, edited) {
+	return storedConsentNames(fields, stored).filter((name) => !sameConsent(stored[name], edited[name]));
+}
+/** Said when the builder is asked to make a consent optional. */
+const CONSENT_REQUIRED_REASON = "A consent is always required: an answer nobody has to give records nothing";
+/**
+* A field as the builder keeps it after an edit, or why the edit is refused.
+* A consent stays required, so turning Required off is refused and said; a
+* field just made a consent becomes required, with a text to agree to.
+*/
+function consentFieldEdit(before, after) {
+	if (after.type !== "consent") return { field: after };
+	if (before.type === "consent" && after.required !== true) return { refused: CONSENT_REQUIRED_REASON };
+	const text = after.agreementText;
+	return { field: {
+		...after,
+		required: true,
+		agreementText: typeof text === "string" ? text : "I agree to the privacy policy"
+	} };
+}
+/** Said when a consent has no text to agree to. */
+const CONSENT_TEXT_REQUIRED = "A consent field needs the text the visitor agrees to.";
+/**
+* The consent fields with no text to agree to. A consent with a blank text
+* would record agreement to nothing, so a form holding one is not saved, by
+* the builder or any other door.
+*/
+function blankConsentFields(fields) {
+	return fields.filter((field) => field.type === "consent" && (typeof field.agreementText !== "string" || field.agreementText.trim() === ""));
+}
+/** Said when a visitor agreed to a text the form no longer shows. */
+const CONSENT_TEXT_CHANGED = "The text to agree to has changed since the form was loaded. Review it and agree again.";
+/**
+* The consent fields a new submission agreed to under a text the form no
+* longer shows. A visitor who sends the text they were shown (an answer of
+* `{ agreed, text }`) is held to it: if the author changed it while the form
+* was open, the submission is refused rather than recorded as agreement to
+* terms the visitor never saw. A bare yes carries no text, so it is taken
+* as agreement to the text the form shows now.
+*/
+function staleConsentNames(fields, data) {
+	return fields.filter((field) => field.type === "consent").filter((field) => {
+		const sent = data[field.name];
+		if (!sent || typeof sent !== "object" || Array.isArray(sent)) return false;
+		const text = sent.text;
+		return typeof text === "string" && text !== field.agreementText;
+	}).map((field) => field.name);
+}
+
 // src/utils/export-formats.ts
 /** UTF-8 BOM character sequence */
 const UTF8_BOM = "";
@@ -721,6 +953,9 @@ function formatExportValue(value, field) {
 			return safeString(value);
 		case "time": return safeString(value);
 		case "hidden": return safeString(value);
+		case "consent":
+			if (isConsentAnswer(value)) return `${value.agreed ? "Agreed" : "Not agreed"}: "${value.text}"`;
+			return safeString(value);
 	}
 	if (Array.isArray(value)) return value.join(", ");
 	if (typeof value === "boolean") return value ? "Yes" : "No";
@@ -728,6 +963,40 @@ function formatExportValue(value, field) {
 	return safeString(value);
 }
 /**
+* A choice answer by its options' labels as asked, several joined. A value
+* no option has (an option removed since) reads as itself.
+*/
+function optionLabels(field, value) {
+	return (Array.isArray(value) ? value : [value]).map((each) => {
+		const text = typeof each === "string" ? each : formatExportValue(each);
+		return field.options?.find((option) => option.value === text)?.label ?? text;
+	}).join(", ");
+}
+/** The kinds of field answered by picking among options. */
+const CHOICE_TYPES = /* @__PURE__ */ new Set(["select", "radio"]);
+/**
+* An answer as one line of text, read with the field as it was asked: a
+* choice by its options' labels, so a list and an export read "Backend
+* engineer" rather than the stored `backend-engineer`; anything else as
+* `formatExportValue` reads it.
+*/
+function answerText(value, field) {
+	if (value === null || value === void 0) return "";
+	return CHOICE_TYPES.has(field.type) ? optionLabels(field, value) : formatExportValue(value, field);
+}
+/**
+* A submission's answers as text, each read with its field as the submission
+* was asked it, or as the form has it now for a field it was not asked (one
+* added since) or a submission stored before submissions kept that. The
+* submissions list and the CSV export both read answers through this, so the
+* two cannot show one answer differently.
+*/
+function answerReader(submission, formFields) {
+	const data = submission.data ?? {};
+	const asked = new Map(askedFieldsOf(submission.asked, formFields, data).fields.map((each) => [each.name, each]));
+	return (field) => answerText(data[field.name], asked.get(field.name) ?? askedField(field));
+}
+/**
 * Format a date for export.
 *
 * @param date - Date value (Date object or string)
@@ -760,7 +1029,8 @@ function escapeCSVValue(value, delimiter = ",") {
 * Export submissions to CSV format.
 *
 * Generates an RFC 4180 compliant CSV string with:
-* - Form field values as columns (in form definition order)
+* - Form field values as columns (in form definition order), headed by the
+*   fields' labels, a choice answer by its option's label
 * - Optional metadata columns at the end (_id, _status, _submittedAt, etc.)
 * - Proper escaping of special characters
 * - Optional UTF-8 BOM for Excel compatibility
@@ -790,12 +1060,8 @@ function exportToCSV(submissions, form, options = {}) {
 	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));
-		}
+		const answer = answerReader(submission, exportableFields);
+		for (const field of exportableFields) row.push(escapeCSVValue(answer(field), delimiter));
 		if (includeMetadata) {
 			row.push(escapeCSVValue(submission.id, delimiter));
 			row.push(escapeCSVValue(submission.status, delimiter));
@@ -1307,62 +1573,149 @@ function normalizeFormSettings(raw) {
 	};
 }
 
-// src/utils/condition-visibility.ts
-/** The names a field's enabled condition reads; none when it has none. */
-function namesRead(field) {
-	const logic = field.conditionalLogic;
-	return logic?.enabled === true ? logic.conditions.map((condition) => condition.field) : [];
+// src/utils/send-status.ts
+/** The states in which another attempt may still come. */
+const IN_PROGRESS = /* @__PURE__ */ new Set([
+	"waiting",
+	"retrying",
+	"sending"
+]);
+/** Where a send stands, an unrecorded one read as waiting. */
+function stateOf(send) {
+	return send.state ?? "waiting";
+}
+/** Whether another attempt at `send` may still come. */
+function sendInProgress(send) {
+	return IN_PROGRESS.has(stateOf(send));
+}
+/** The recipients a send lists: those it went to, else those it was for. */
+function listedOf(send) {
+	const sent = send.recipients ?? [];
+	return sent.length > 0 ? sent : send.configured ?? [];
+}
+/** A recipient's state in one send, from its outcome and the send's state. */
+function recipientState(send, recipient) {
+	if (recipient.outcome === "accepted") return "sent";
+	const state = stateOf(send);
+	if (state === "sent") return "failed";
+	return state;
+}
+/** One recipient's result in one send. */
+function statusIn(send, recipient) {
+	const state = recipientState(send, recipient);
+	return {
+		digest: recipient.digest,
+		hint: recipient.hint,
+		kind: recipient.kind,
+		source: recipient.source,
+		state,
+		retries: state === "sent" ? recipient.retries ?? 0 : 0,
+		at: send.changedAt ?? send.createdAt ?? null,
+		...state === "cancelled" && send.cancel ? { cancel: send.cancel } : {}
+	};
 }
 /**
-* Which of a form's fields its conditions hide, for a given set of answers.
-*
-* A condition reads the answers of fields that are themselves shown, so a
-* hidden field's leftover answer never decides another field, and it may read
-* a field before or after its own. Fields are decided in the order their
-* conditions depend on each other, whatever their order on the form.
-*
-* Conditions can read each other in a loop (A shown when B is answered, B
-* shown when A is), and no order settles a loop. The rule for one: fields in
-* the same loop read each other's answers as given, and only the loop's
-* fields decide it, so an unrelated field elsewhere on the form never changes
-* the outcome.
-*
-* A field of type `hidden` is not one of them: it is sent with every
-* submission, unseen.
+* Every recipient a notification's sends had for a submission, each with its
+* latest result, oldest first. A recipient a send left out (one Resend found
+* already reached) keeps the result it had.
 */
-function fieldsHiddenByCondition(fields, answers) {
-	const byName = new Map(fields.map((field) => [field.name, field]));
-	const reach = /* @__PURE__ */ new Map();
-	/** Every field `name`'s condition depends on, directly or through others. */
-	const dependsOn = (name) => {
-		const known = reach.get(name);
-		if (known) return known;
-		const found = /* @__PURE__ */ new Set();
-		reach.set(name, found);
-		const pending = [name];
-		for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
-			const field = byName.get(next);
-			for (const read of field ? namesRead(field) : []) if (!found.has(read)) {
-				found.add(read);
-				pending.push(read);
-			}
-		}
-		return found;
+function latestByRecipient(sends) {
+	const latest = /* @__PURE__ */ new Map();
+	for (const send of sends) for (const recipient of listedOf(send)) {
+		if (recipient.outcome === "skipped") continue;
+		latest.set(recipient.digest, statusIn(send, recipient));
+	}
+	return [...latest.values()];
+}
+/**
+* Who Resend can send a notification to now: each recipient the notification
+* addresses as it is now (`configured`), then each recipient a send filter
+* added that its sends have not reached, since the filters add it again to
+* the next send. Whether each has received it is read from `history`, the
+* latest result per recipient.
+*/
+function addressableNow(configured, history) {
+	const latest = new Map(history.map((status) => [status.digest, status]));
+	const now = configured.map((recipient) => ({
+		digest: recipient.digest,
+		hint: recipient.hint,
+		source: recipient.source,
+		reached: latest.get(recipient.digest)?.state === "sent"
+	}));
+	const listed = new Set(now.map((recipient) => recipient.digest));
+	const missedAdded = history.filter((status) => status.source === "added" && status.state !== "sent" && !listed.has(status.digest)).map((status) => ({
+		digest: status.digest,
+		hint: status.hint,
+		source: status.source,
+		reached: false
+	}));
+	return [...now, ...missedAdded];
+}
+/**
+* The recipients a resend leaves out: each one `history` shows has received
+* it, except those ticked to send it to again.
+*/
+function reachedExcept(history, ticked) {
+	const again = new Set(ticked);
+	return history.filter((status) => status.state === "sent" && !again.has(status.digest)).map((status) => status.digest);
+}
+/** A recipient's status in words. */
+function recipientLook(status) {
+	switch (status.state) {
+		case "sent": return status.retries === 0 ? {
+			label: "Sent",
+			tone: "ok"
+		} : {
+			label: `Sent after ${status.retries} ${status.retries === 1 ? "retry" : "retries"}`,
+			tone: "warn"
+		};
+		case "failed": return {
+			label: "Failed",
+			tone: "bad"
+		};
+		case "cancelled": return {
+			label: "Cancelled",
+			tone: "quiet"
+		};
+		case "sending": return {
+			label: "Sending",
+			tone: "quiet"
+		};
+		case "retrying": return {
+			label: "Retrying",
+			tone: "warn"
+		};
+		default: return {
+			label: "Waiting",
+			tone: "quiet"
+		};
+	}
+}
+/**
+* A notification's status in words: the one its recipients share, or Partly
+* sent when they differ. Recipients all sent read as the one that took the
+* most retries.
+*/
+function notificationLook(statuses) {
+	const [first] = statuses;
+	if (!first) return {
+		label: "Waiting",
+		tone: "quiet"
 	};
-	const shown = /* @__PURE__ */ new Map();
-	/** Whether field `name` is on the page, deciding what it reads first. */
-	const isShown = (name) => {
-		const decided = shown.get(name);
-		if (decided !== void 0) return decided;
-		const field = byName.get(name);
-		const logic = field?.conditionalLogic;
-		if (!field || logic?.enabled !== true) return true;
-		const read = Object.fromEntries(Object.entries(answers).filter(([other]) => !byName.has(other) || !namesRead(field).includes(other) || dependsOn(other).has(name) || isShown(other)));
-		const result = evaluateConditions(logic, read);
-		shown.set(name, result);
-		return result;
+	if (!statuses.every((status) => status.state === first.state)) return {
+		label: "Partly sent",
+		tone: "warn"
 	};
-	return new Set(fields.filter((field) => !isShown(field.name)).map((field) => field.name));
+	return recipientLook(statuses.reduce((latest, status) => status.retries > latest.retries ? status : latest, first));
+}
+/** Why a send was cancelled, in words. */
+function cancelText(cancel) {
+	switch (cancel?.by) {
+		case "person": return "Cancelled in Settings › Email";
+		case "spam": return "Cancelled when the submission was marked Spam";
+		case "erasure": return "Cancelled when the address was erased";
+		default: return "Cancelled";
+	}
 }
 
 // src/types.ts
@@ -1381,7 +1734,8 @@ const BUILT_IN_FORM_FIELD_TYPES = [
 	"file",
 	"date",
 	"time",
-	"hidden"
+	"hidden",
+	"consent"
 ];
 const BUILT_IN_FORM_FIELD_TYPES_SET = new Set(BUILT_IN_FORM_FIELD_TYPES);
 /**
@@ -1471,7 +1825,8 @@ const ENFORCED_VALIDATION_RULES = {
 	file: ["message"],
 	date: ["message"],
 	time: ["message"],
-	hidden: ["message"]
+	hidden: ["message"],
+	consent: ["message"]
 };
 /**
 * The rules a field of this type both accepts and has enforced.
@@ -1517,10 +1872,24 @@ function generateZodSchema(fields) {
 			continue;
 		}
 		const fieldSchema = generateFieldSchema(field);
-		if (fieldSchema) schemaShape[field.name] = fieldSchema;
+		if (fieldSchema) schemaShape[field.name] = field.required ? answered(fieldSchema, requiredMessage(field)) : fieldSchema;
 	}
 	return z.object(schemaShape);
 }
+/** What a required field missing from a submission says. */
+function requiredMessage(field) {
+	return customMessage(field) || `${field.label || field.name} is required`;
+}
+/**
+* `schema`, after a check that an answer was given at all. A required field
+* left out of a submission would otherwise fail on its type ("expected
+* string, received undefined"), which tells the visitor nothing; it is
+* refused as required instead, and the field's own checks run on an answer
+* that is there.
+*/
+function answered(schema, message) {
+	return z.custom((value) => value !== void 0 && value !== null, { message }).pipe(schema);
+}
 /**
 * Generate a Zod schema for a single field.
 */
@@ -1539,6 +1908,7 @@ function generateFieldSchema(field) {
 		case "date": return generateDateSchema(field);
 		case "time": return generateTimeSchema(field);
 		case "hidden": return generateHiddenSchema(field);
+		case "consent": return generateConsentSchema(field);
 		default: return z.unknown();
 	}
 }
@@ -1748,6 +2118,17 @@ function generateTimeSchema(field) {
 	return applyRequired(z.string().regex(/^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/, customMessage(field) || "Invalid time format (HH:mm)"), field.required, customMessage(field));
 }
 /**
+* Generate schema for a consent field: the stored answer, which must say the
+* visitor agreed. Always required, whatever the field's own flag says, since
+* a consent nobody has to give records nothing.
+*/
+function generateConsentSchema(field) {
+	return z.object({
+		agreed: z.boolean(),
+		text: z.string()
+	}).refine((answer) => answer.agreed, { message: customMessage(field) || "This field is required" });
+}
+/**
 * Generate schema for hidden field.
 */
 function generateHiddenSchema(field) {
@@ -1805,6 +2186,7 @@ function transformFieldValue(value, field) {
 		case "hidden":
 			if (typeof value === "string") return value.trim();
 			return value;
+		case "consent": return consentAnswerOf(value, field);
 		case "select":
 			if (field.allowMultiple) {
 				if (!Array.isArray(value)) return value ? [value] : [];
@@ -1921,6 +2303,225 @@ function oneResponseEditProblem(before, after, settings) {
 	return comparesByEmail(after) ? void 0 : ONE_RESPONSE_FIELD_REASON;
 }
 
+// src/utils/sent-from.ts
+/**
+* The page a submission was sent from, as the submission keeps it: the web
+* address the visitor's browser reported in `Referer`, reduced to its origin
+* and path. Its query and fragment are dropped, since a page's address can
+* carry personal data there (a search, an email in a link, a token), and an
+* address that is not a web page (another scheme, or none) is not kept. The
+* browser reports it, so it is a hint for staff, not evidence.
+*
+* @module utils/sent-from
+*/
+/** The longest address kept, in characters; a longer one is not kept. */
+const PAGE_MAX = 2048;
+/** The page a `Referer` names, or undefined when it names no web page. */
+function pageFromReferer(referer) {
+	if (!referer) return void 0;
+	let url;
+	try {
+		url = new URL(referer);
+	} catch {
+		return;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
+	const page = `${url.origin}${url.pathname}`;
+	return page.length <= PAGE_MAX ? page : void 0;
+}
+
+// src/admin/components/submissions/submission-list-scope.ts
+const STATUS_TABS = [
+	"all",
+	"new",
+	"read",
+	"archived",
+	"spam"
+];
+/**
+* The scope's dates as a filter of `submittedAt`, or none for any date. The
+* upper bound is exclusive, so a range ending at the start of a day leaves
+* that day out, whatever the precision a dialect stores the time with.
+*/
+function sentBetween(scope) {
+	if (!scope.from && !scope.to) return void 0;
+	return {
+		...scope.from ? { greater_than_equal: scope.from } : {},
+		...scope.to ? { less_than: scope.to } : {}
+	};
+}
+/** The list's filter as the entries API takes it. */
+function listWhere(scope) {
+	const where = {};
+	if (scope.form) where.form = { equals: scope.form };
+	where.status = scope.status === "all" ? { not_equals: "spam" } : { equals: scope.status };
+	const sent = sentBetween(scope);
+	if (sent) where.submittedAt = sent;
+	return where;
+}
+/**
+* The list's order: newest first, and among submissions sent at the same
+* moment, by id. The id makes the order total, so a submission's newer and
+* older neighbours are always defined even when timestamps tie (imported
+* rows can share one). It is the tiebreak the entries API adds last anyway,
+* spelled out so the page's neighbour queries mirror it exactly.
+*/
+const LIST_SORT = "-submittedAt,id";
+/**
+* The list a submission's page counts it in: the list's filter, and the
+* submission itself. Opened from the New tab, the submission is marked Read
+* and leaves that filter; archiving or recovering it can too. Counted with
+* it, the page's "3 of 3" stays true to the list it was opened from rather
+* than reading "3 of 2", and its newer neighbours still count its place.
+*/
+function listWithWhere(scope, id) {
+	return { or: [listWhere(scope), { id: { equals: id } }] };
+}
+/**
+* The queries that find the submissions just newer and just older than the
+* one sent at `at` with id `id`, in LIST_SORT's order: each side is a strict
+* comparison on the timestamp, or the same timestamp and the id on that side.
+* The newer side is read in reverse, so its first row is the nearest one, and
+* its total is how many rows come before this submission in the list.
+*/
+function neighbourQueries(scope, at, id) {
+	const base = listWhere(scope);
+	const side = (time, tie) => ({
+		...base,
+		or: [{ submittedAt: { [time]: at } }, { and: [{ submittedAt: { equals: at } }, { id: { [tie]: id } }] }]
+	});
+	return {
+		newer: {
+			where: side("greater_than", "less_than"),
+			sort: "submittedAt,-id"
+		},
+		older: {
+			where: side("less_than", "greater_than"),
+			sort: LIST_SORT
+		}
+	};
+}
+/** The scope as an address carries it: a submission page's, or the export's. */
+function scopeParams(scope) {
+	const params = new URLSearchParams({ status: scope.status });
+	if (scope.form) params.set("form", scope.form);
+	if (scope.from) params.set("from", scope.from);
+	if (scope.to) params.set("to", scope.to);
+	return params;
+}
+/** A moment an address names, as an ISO date and time; none for anything else. */
+function momentOf(text) {
+	if (!text) return void 0;
+	const at = Date.parse(text);
+	return Number.isNaN(at) ? void 0 : new Date(at).toISOString();
+}
+/**
+* The scope an address carries, read defensively: an unknown status reads as
+* "all" and a date that is not one as no bound, so a hand-edited address
+* still lists something.
+*/
+function scopeFromSearch(search) {
+	const params = new URLSearchParams(search);
+	const status = params.get("status");
+	const form = params.get("form");
+	const from = momentOf(params.get("from"));
+	const to = momentOf(params.get("to"));
+	return {
+		status: STATUS_TABS.includes(status) ? status : "all",
+		...form ? { form } : {},
+		...from ? { from } : {},
+		...to ? { to } : {}
+	};
+}
+/** A submission's page, opened from the list `scope`. */
+function submissionPageAddress(submissionsSlug, id, scope) {
+	return `/admin/collections/${encodeURIComponent(submissionsSlug)}/${encodeURIComponent(id)}?${scopeParams(scope).toString()}`;
+}
+/** The export route, as the admin's API serves it. */
+const EXPORT_ROUTE = "/admin/api/plugins/@nextlyhq/plugin-form-builder/submissions/export";
+/**
+* The export of what a list shows, in `format`: every submission its scope
+* matches, or, given `ids`, exactly those (the rows ticked in it).
+*/
+function exportAddress(scope, format, ids) {
+	const params = scopeParams(scope);
+	params.set("format", format);
+	if (ids !== void 0) params.set("ids", ids.join(","));
+	return `${EXPORT_ROUTE}?${params.toString()}`;
+}
+
+// src/utils/notification-model.ts
+/**
+* Split typed addresses into a list: separated by commas, semicolons,
+* spaces or new lines, each trimmed, blanks and repeats dropped.
+*/
+function parseAddressList(text) {
+	const seen = /* @__PURE__ */ new Set();
+	const list = [];
+	for (const part of text.split(/[\s,;]+/)) {
+		const address = part.trim();
+		if (!address || seen.has(address.toLowerCase())) continue;
+		seen.add(address.toLowerCase());
+		list.push(address);
+	}
+	return list;
+}
+/**
+* A team notification's addresses: its list, or the single address it was
+* saved with. Trimmed, blanks dropped.
+*/
+function teamAddressesOf(notification) {
+	return (Array.isArray(notification.recipients) ? notification.recipients : typeof notification.to === "string" ? [notification.to] : []).map((address) => typeof address === "string" ? address.trim() : "").filter(Boolean);
+}
+/** A notification's conditions, as a match and a list. */
+function conditionsOf(notification) {
+	const stored = notification.conditions;
+	if (stored && Array.isArray(stored.list)) return {
+		match: stored.match === "any" ? "any" : "all",
+		list: stored.list.filter(isCondition)
+	};
+	return {
+		match: "all",
+		list: notification.condition ? [notification.condition] : []
+	};
+}
+function isCondition(value) {
+	return !!value && typeof value === "object" && typeof value.field === "string" && typeof value.comparison === "string";
+}
+/**
+* Whether a notification sends for these answers: every condition holds
+* (all) or one does (any). One with no conditions always sends.
+*/
+function conditionsMet(conditions, data) {
+	if (conditions.list.length === 0) return true;
+	const holds = (condition) => evaluateSingleCondition(condition, data);
+	return conditions.match === "any" ? conditions.list.some(holds) : conditions.list.every(holds);
+}
+/**
+* The file fields whose files go with a notification, by name: its own
+* choice, or for a rule saved before it, the fields marked to attach.
+*/
+function attachFieldsOf(notification, fields) {
+	if (Array.isArray(notification.attachFields)) return notification.attachFields.filter((name) => typeof name === "string");
+	return fieldsMarkedToAttach(fields);
+}
+/**
+* The file fields marked to attach to notification emails, by name: what
+* every email carried before each notification chose its own.
+*/
+function fieldsMarkedToAttach(fields) {
+	return fields.filter((field) => field.type === "file" && field.attachToEmail === true && typeof field.name === "string").map((field) => field.name);
+}
+/** The media ids a submission holds under the named file fields. */
+function attachmentsFrom(fieldNames, data) {
+	const attachments = [];
+	for (const name of fieldNames) {
+		const value = data[name];
+		for (const item of Array.isArray(value) ? value : [value]) if (typeof item === "string" && item) attachments.push({ mediaId: item });
+	}
+	return attachments;
+}
+
 // src/utils/field-references.ts
 /**
 * The one spelling of a field reference this plugin recognises: `{{fieldName}}`
@@ -1983,8 +2584,9 @@ function findFieldReferences(fieldName, fields, notifications, settings) {
 			...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({
+		const referencedByCondition = conditionsOf(notification).list.some((condition) => condition.field === fieldName);
+		const referencedByAttachment = notification.attachFields?.includes(fieldName) ?? false;
+		if (referencedByTemplate || referencedByCondition || referencedByAttachment) references.push({
 			kind: "notification",
 			label: notification.name || "Notification"
 		});
@@ -2024,7 +2626,8 @@ function renameInFieldConditions(fields, from, to) {
 }
 /**
 * The notifications with every reference to `from` naming `to` instead: the
-* addresses (`{{ from }}`) and the condition `findFieldReferences` reads.
+* addresses (`{{ from }}`), the conditions and the attached file fields
+* `findFieldReferences` reads.
 */
 function renameInNotifications(notifications, from, to) {
 	const pattern = templatePattern(from, "g");
@@ -2042,9 +2645,55 @@ function renameInNotifications(notifications, from, to) {
 			...notification.condition,
 			field: to
 		};
+		if (notification.conditions) next.conditions = {
+			...notification.conditions,
+			list: notification.conditions.list.map((condition) => condition.field === from ? {
+				...condition,
+				field: to
+			} : condition)
+		};
+		if (notification.attachFields) next.attachFields = notification.attachFields.map((name) => name === from ? to : name);
 		return next;
 	});
 }
 
-export { SCHEMA_ONLY_READ as $, applyFieldDefaults as A, downloadFile as B, isKnownFormField as C, normalizeFormSettings as D, fieldsHiddenByCondition as E, warnIfWebhooksConfigured as F, generateExportFilename as G, exportToCSV as H, FORM_CONFIRMATION_TEMPLATE as I, getSupportedComparisonOperators as J, evaluateConditions as K, FORM_SUBMISSION_TEMPLATE as L, createFormConfig as M, pluralize as N, DEFAULT_FORM_SETTINGS as O, toTitleCase as P, SCHEMA_ONLY_CONTEXT as Q, formsEmailTemplates as R, isFormFieldType as S, isTextFormField as T, exportToJSON as U, exportAndDownload as V, formatExportValue as W, NEW_SUBMISSIONS_WIDGET_ID as X, isValidComparisonOperator as Y, readNewSubmissions as Z, BUILT_IN_FORM_FIELD_TYPES as _, renameInNotifications as a, addressedFormPages as at, isFileFormField as b, emailFieldsToCompare as c, generateZodSchema as d, documentReachability as et, getValidationErrors as f, enforcedValidationRules as g, validateFormData as h, renameInFieldConditions as i, FORM_PAGES as it, applyFormDefaults as j, DEFAULT_NOTIFICATION_SETTINGS as k, oneResponseEditProblem as l, transformFormData as m, oneResponseEmailField as n, pickedDocumentField as nt, ONE_RESPONSE_FIELD_REASON as o, formPageId as ot, getValidationIssues as p, evaluateSingleCondition as q, parseFieldRef as r, FORM_EDITOR_VIEW as rt, comparesByEmail as s, formPageOf as st, buildFieldReferenceMap as t, parseRedirectReference as tt, oneResponseFieldProblem as u, isCheckboxFormField as v, isSelectFormField as w, isFormField as x, isEmailFormField as y, starterTemplateFor as z };
-//# sourceMappingURL=field-references-oCuFEwkr.js.map
+// src/utils/submission-title.ts
+/**
+* Who sent a submission, as the admin names it: the first answer to a text
+* field named or labelled as a name, else the first email address answered,
+* else none. One rule, read by the write seam (which keeps it as the
+* submission's title, the admin's breadcrumb and list name) and by the
+* submission's page.
+*
+* @module utils/submission-title
+*/
+/**
+* The longest title kept, in characters. The title is a display copy of an
+* answer, stored as a text column, which MySQL holds to 255 characters; an
+* answer has no such limit, so a longer one is shortened here rather than
+* refusing the submission it names.
+*/
+const TITLE_MAX = 200;
+/**
+* The title a submission is stored with: who sent it, shortened to
+* TITLE_MAX characters with an ellipsis, or none.
+*/
+function submissionTitleOf(fields, data) {
+	const sender = senderOf(fields, data);
+	if (sender === void 0) return void 0;
+	const characters = Array.from(sender);
+	return characters.length <= TITLE_MAX ? sender : `${characters.slice(0, 199).join("").trimEnd()}…`;
+}
+function senderOf(fields, data) {
+	const answer = (name) => {
+		const value = data[name];
+		return typeof value === "string" ? value.trim() : "";
+	};
+	const named = fields.find((field) => field.type === "text" && /name/i.test(`${field.name} ${field.label ?? ""}`) && answer(field.name));
+	if (named) return answer(named.name);
+	const email = fields.find((field) => field.type === "email" && answer(field.name));
+	return email ? answer(email.name) : void 0;
+}
+
+export { applyFieldDefaults as $, getValidationIssues as A, fieldsHiddenByCondition as At, isKnownFormField as B, pickedDocumentField as Bt, ONE_RESPONSE_FIELD_REASON as C, isConsentAnswer as Ct, oneResponseFieldProblem as D, askedFieldsOf as Dt, oneResponseEditProblem as E, askedAfterEdit as Et, isCheckboxFormField as F, readNewSubmissions as Ft, latestByRecipient as G, formPageOf as Gt, isTextFormField as H, FORM_PAGES as Ht, isEmailFormField as I, SCHEMA_ONLY_CONTEXT as It, recipientLook as J, notificationLook as K, isFileFormField as L, SCHEMA_ONLY_READ as Lt, validateFormData as M, getSupportedComparisonOperators as Mt, enforcedValidationRules as N, isValidComparisonOperator as Nt, generateZodSchema as O, askedSnapshotOf as Ot, BUILT_IN_FORM_FIELD_TYPES as P, NEW_SUBMISSIONS_WIDGET_ID as Pt, DEFAULT_NOTIFICATION_SETTINGS as Q, isFormField as R, documentReachability as Rt, pageFromReferer as S, editedConsents as St, emailFieldsToCompare as T, storedConsentNames as Tt, addressableNow as U, addressedFormPages as Ut, isSelectFormField as V, FORM_EDITOR_VIEW as Vt, cancelText as W, formPageId as Wt, normalizeFormSettings as X, sendInProgress as Y, DEFAULT_FORM_SETTINGS as Z, listWhere as _, CONSENT_EDIT_REFUSED as _t, parseFieldRef as a, FORM_CONFIRMATION_TEMPLATE as at, scopeFromSearch as b, blankConsentFields as bt, attachFieldsOf as c, starterTemplateFor as ct, conditionsOf as d, exportAndDownload as dt, applyFormDefaults as et, fieldsMarkedToAttach as f, exportToCSV as ft, exportAddress as g, optionLabels as gt, LIST_SORT as h, generateExportFilename as ht, oneResponseEmailField as i, warnIfWebhooksConfigured as it, transformFormData as j, evaluateConditions as jt, getValidationErrors as k, readAskedSnapshot as kt, attachmentsFrom as l, answerReader as lt, teamAddressesOf as m, formatExportValue as mt, submissionTitleOf as n, pluralize as nt, renameInFieldConditions as o, FORM_SUBMISSION_TEMPLATE as ot, parseAddressList as p, exportToJSON as pt, reachedExcept as q, buildFieldReferenceMap as r, toTitleCase as rt, renameInNotifications as s, formsEmailTemplates as st, senderOf as t, createFormConfig as tt, conditionsMet as u, downloadFile as ut, listWithWhere as v, CONSENT_TEXT_CHANGED as vt, comparesByEmail as w, staleConsentNames as wt, submissionPageAddress as x, consentFieldEdit as xt, neighbourQueries as y, CONSENT_TEXT_REQUIRED as yt, isFormFieldType as z, parseRedirectReference as zt };
+//# sourceMappingURL=submission-title-CVixn15Z.js.map