@10x-media/form-builder 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/poll/buildPollOptionSourceFields.js

@@ -0,0 +1,50 @@
+import { keys } from "../translations/keys.js";
+import { labelForKey, resolveDefinitionLabel } from "../translations/server.js";
+//#region src/poll/buildPollOptionSourceFields.ts
+/**
+* Builds the `optionSource` select and `sourceConfig` group for the forms poll group; returns
+* nothing when no sources are registered, so the fields only exist for hosts that opted in.
+* Fields inside `sourceConfig` are annotated with `admin.condition` so only the fields of the
+* currently selected source type are visible; like consent's `sourceConfig`, field names within
+* the group must be unique across all registered sources. Unlike consent's `source` select there
+* is no default: hand-authored options remain the baseline and a source is an explicit opt-in per
+* form (the select stays clearable).
+*/
+const buildPollOptionSourceFields = (registry) => {
+	const sources = [...registry.values()];
+	if (sources.length === 0) return [];
+	const sourceConfigFields = sources.flatMap((source) => (source.config ?? []).map((field) => {
+		const existingAdmin = typeof field.admin === "object" && field.admin !== null ? field.admin : {};
+		return {
+			...field,
+			admin: {
+				...existingAdmin,
+				condition: (data) => data?.poll?.optionSource === source.type
+			}
+		};
+	}));
+	return [{
+		name: "optionSource",
+		type: "select",
+		label: labelForKey(keys.pollOptionSource),
+		admin: { description: labelForKey(keys.pollOptionSourceDescription) },
+		options: sources.map((source) => ({
+			label: resolveDefinitionLabel(source.label),
+			value: source.type
+		}))
+	}, {
+		name: "sourceConfig",
+		type: "group",
+		label: labelForKey(keys.pollSourceConfig),
+		admin: { condition: (_data, siblingData) => Boolean(siblingData?.optionSource) },
+		fields: sourceConfigFields.length > 0 ? sourceConfigFields : [{
+			name: "_placeholder",
+			type: "text",
+			admin: { hidden: true }
+		}]
+	}];
+};
+//#endregion
+export { buildPollOptionSourceFields };
+
+//# sourceMappingURL=buildPollOptionSourceFields.js.map

package/dist/poll/buildPollOptionSourceFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildPollOptionSourceFields.js","names":[],"sources":["../../src/poll/buildPollOptionSourceFields.ts"],"sourcesContent":["import type { Field } from 'payload'\nimport { keys } from '../translations/keys'\nimport { labelForKey, resolveDefinitionLabel } from '../translations/server'\nimport type { PollOptionSourceRegistry } from './registry'\n\n/**\n * Builds the `optionSource` select and `sourceConfig` group for the forms poll group; returns\n * nothing when no sources are registered, so the fields only exist for hosts that opted in.\n * Fields inside `sourceConfig` are annotated with `admin.condition` so only the fields of the\n * currently selected source type are visible; like consent's `sourceConfig`, field names within\n * the group must be unique across all registered sources. Unlike consent's `source` select there\n * is no default: hand-authored options remain the baseline and a source is an explicit opt-in per\n * form (the select stays clearable).\n */\nexport const buildPollOptionSourceFields = (registry: PollOptionSourceRegistry): Field[] => {\n\tconst sources = [...registry.values()]\n\tif (sources.length === 0) {\n\t\treturn []\n\t}\n\n\tconst sourceConfigFields: Field[] = sources.flatMap((source) =>\n\t\t(source.config ?? []).map((field) => {\n\t\t\tconst existingAdmin =\n\t\t\t\ttypeof field.admin === 'object' && field.admin !== null ? field.admin : {}\n\t\t\treturn {\n\t\t\t\t...field,\n\t\t\t\tadmin: {\n\t\t\t\t\t...existingAdmin,\n\t\t\t\t\tcondition: (data: unknown) =>\n\t\t\t\t\t\t(data as { poll?: { optionSource?: string } })?.poll?.optionSource === source.type,\n\t\t\t\t},\n\t\t\t} as Field\n\t\t})\n\t)\n\n\treturn [\n\t\t{\n\t\t\tname: 'optionSource',\n\t\t\ttype: 'select',\n\t\t\tlabel: labelForKey(keys.pollOptionSource),\n\t\t\tadmin: {\n\t\t\t\tdescription: labelForKey(keys.pollOptionSourceDescription),\n\t\t\t},\n\t\t\toptions: sources.map((source) => ({\n\t\t\t\tlabel: resolveDefinitionLabel(source.label),\n\t\t\t\tvalue: source.type,\n\t\t\t})),\n\t\t},\n\t\t{\n\t\t\tname: 'sourceConfig',\n\t\t\ttype: 'group',\n\t\t\tlabel: labelForKey(keys.pollSourceConfig),\n\t\t\tadmin: {\n\t\t\t\tcondition: (_data, siblingData) => Boolean(siblingData?.optionSource),\n\t\t\t},\n\t\t\tfields:\n\t\t\t\tsourceConfigFields.length > 0\n\t\t\t\t\t? sourceConfigFields\n\t\t\t\t\t: [{ name: '_placeholder', type: 'text', admin: { hidden: true } }],\n\t\t},\n\t]\n}\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,+BAA+B,aAAgD;CAC3F,MAAM,UAAU,CAAC,GAAG,SAAS,OAAO,CAAC;CACrC,IAAI,QAAQ,WAAW,GACtB,OAAO,CAAC;CAGT,MAAM,qBAA8B,QAAQ,SAAS,YACnD,OAAO,UAAU,CAAC,GAAG,KAAK,UAAU;EACpC,MAAM,gBACL,OAAO,MAAM,UAAU,YAAY,MAAM,UAAU,OAAO,MAAM,QAAQ,CAAC;EAC1E,OAAO;GACN,GAAG;GACH,OAAO;IACN,GAAG;IACH,YAAY,SACV,MAA+C,MAAM,iBAAiB,OAAO;GAChF;EACD;CACD,CAAC,CACF;CAEA,OAAO,CACN;EACC,MAAM;EACN,MAAM;EACN,OAAO,YAAY,KAAK,gBAAgB;EACxC,OAAO,EACN,aAAa,YAAY,KAAK,2BAA2B,EAC1D;EACA,SAAS,QAAQ,KAAK,YAAY;GACjC,OAAO,uBAAuB,OAAO,KAAK;GAC1C,OAAO,OAAO;EACf,EAAE;CACH,GACA;EACC,MAAM;EACN,MAAM;EACN,OAAO,YAAY,KAAK,gBAAgB;EACxC,OAAO,EACN,YAAY,OAAO,gBAAgB,QAAQ,aAAa,YAAY,EACrE;EACA,QACC,mBAAmB,SAAS,IACzB,qBACA,CAAC;GAAE,MAAM;GAAgB,MAAM;GAAQ,OAAO,EAAE,QAAQ,KAAK;EAAE,CAAC;CACrE,CACD;AACD"}

package/dist/poll/closeJob.d.ts

@@ -0,0 +1,53 @@
+import { Config, Payload, PayloadRequest, TaskConfig } from "payload";
+
+//#region src/poll/closeJob.d.ts
+declare const POLL_CLOSE_TASK_SLUG = "form-builder-poll-close";
+/** Input the enqueue path stores; the handler re-loads everything else from the DB. */
+type PollCloseTaskInput = {
+  formId: number | string;
+};
+/** The slice of a loaded form the close gate reads. */
+type PollFormLike = {
+  pollEnabled?: boolean | null;
+  poll?: unknown;
+};
+/**
+ * True when a poll's outcome should auto-resolve now: enabled, closed, still unresolved, and its
+ * strategy is not `manual`. Shared by the close-job handler and the results-read fallback so the two
+ * triggers apply the exact same gate.
+ */
+declare const shouldAutoResolvePoll: (form: PollFormLike) => boolean;
+/**
+ * Run the scheduled close for one form. Idempotent: re-loads the form and only resolves when the
+ * poll is enabled, closed, still unresolved, and not `manual`, so a re-run after the outcome was
+ * recorded (or a job that fires slightly early) is a safe no-op. Tolerates a deleted form.
+ */
+declare const runPollClose: (args: {
+  payload: Payload;
+  input: PollCloseTaskInput; /** Whether the hidden tally store backs the outcome aggregation (see `resolvePollOutcome`). */
+  pollVotesEnabled?: boolean;
+  req?: PayloadRequest;
+}) => Promise<void>;
+/** Native Payload jobs task that resolves a poll's outcome once it closes. */
+declare const buildPollCloseTask: (pollVotesEnabled?: boolean) => TaskConfig;
+/** Register the poll-close task on `config.jobs.tasks`, creating the jobs config if absent. */
+declare const registerPollCloseTask: (config: Config, pollVotesEnabled?: boolean) => void;
+/**
+ * Schedule (or reschedule) the auto-close for a poll after a save. Enqueues a `waitUntil: closesAt`
+ * job when the poll is enabled, has a `closesAt`, is still unresolved, and its strategy is not
+ * `manual`, and only when a job runner is present (`payload.jobs.queue`); otherwise the resolve-on-read
+ * fallback is the safety net. Any prior pending close job for the form is deleted first so the newest
+ * `closesAt` wins. Never throws; a queue failure is logged and swallowed.
+ */
+declare const enqueuePollClose: (args: {
+  payload: Payload;
+  form: {
+    id: number | string;
+    pollEnabled?: boolean | null;
+    poll?: unknown;
+  };
+  req?: PayloadRequest;
+}) => Promise<void>;
+//#endregion
+export { POLL_CLOSE_TASK_SLUG, PollCloseTaskInput, buildPollCloseTask, enqueuePollClose, registerPollCloseTask, runPollClose, shouldAutoResolvePoll };
+//# sourceMappingURL=closeJob.d.ts.map

package/dist/poll/closeJob.js

@@ -0,0 +1,121 @@
+import { isPollClosed, pollConfigOf } from "../form/pollState.js";
+import { resolvePollOutcome } from "./resolvePollOutcome.js";
+import { FORMS_SLUG } from "../collections/forms.js";
+//#region src/poll/closeJob.ts
+const POLL_CLOSE_TASK_SLUG = "form-builder-poll-close";
+/** Payload's jobs collection; queried directly to supersede a superseded pending close job. */
+const JOBS_SLUG = "payload-jobs";
+const hasEmptyWinners = (poll) => {
+	const winners = poll.outcome?.winningValues;
+	return !Array.isArray(winners) || winners.filter((value) => typeof value === "string" && value.length > 0).length === 0;
+};
+const strategyOf = (poll) => typeof poll.type === "string" && poll.type.length > 0 ? poll.type : "manual";
+/**
+* True when a poll's outcome should auto-resolve now: enabled, closed, still unresolved, and its
+* strategy is not `manual`. Shared by the close-job handler and the results-read fallback so the two
+* triggers apply the exact same gate.
+*/
+const shouldAutoResolvePoll = (form) => {
+	const poll = pollConfigOf(form.poll);
+	return form.pollEnabled === true && poll != null && isPollClosed(poll) && hasEmptyWinners(poll) && strategyOf(poll) !== "manual";
+};
+/**
+* Run the scheduled close for one form. Idempotent: re-loads the form and only resolves when the
+* poll is enabled, closed, still unresolved, and not `manual`, so a re-run after the outcome was
+* recorded (or a job that fires slightly early) is a safe no-op. Tolerates a deleted form.
+*/
+const runPollClose = async (args) => {
+	const { payload, input, pollVotesEnabled, req } = args;
+	const form = await payload.findByID({
+		collection: FORMS_SLUG,
+		id: input.formId,
+		depth: 0,
+		overrideAccess: true,
+		req
+	}).catch(() => null);
+	if (!form || !shouldAutoResolvePoll(form)) return;
+	await resolvePollOutcome({
+		payload,
+		formId: input.formId,
+		pollVotesEnabled,
+		req
+	});
+};
+/** Native Payload jobs task that resolves a poll's outcome once it closes. */
+const buildPollCloseTask = (pollVotesEnabled = false) => ({
+	slug: POLL_CLOSE_TASK_SLUG,
+	inputSchema: [{
+		name: "formId",
+		type: "text",
+		required: true
+	}],
+	handler: async ({ input, req }) => {
+		await runPollClose({
+			payload: req.payload,
+			input,
+			pollVotesEnabled,
+			req
+		});
+		return { output: {} };
+	}
+});
+/** Register the poll-close task on `config.jobs.tasks`, creating the jobs config if absent. */
+const registerPollCloseTask = (config, pollVotesEnabled = false) => {
+	config.jobs ??= {};
+	config.jobs.tasks ??= [];
+	config.jobs.tasks.push(buildPollCloseTask(pollVotesEnabled));
+};
+const canQueue = (payload) => typeof payload.jobs?.queue === "function";
+/**
+* Delete this form's pending (never-run) close jobs so a re-enqueue supersedes the prior one. Payload
+* 3.85's `jobs.queue` has no concurrency key, so this mirrors core's `deleteScheduledPublishJobs`:
+* a direct `db.deleteMany` on the jobs collection, scoped by task slug and the JSON `input.formId`.
+* Best-effort; a failure here only risks a duplicate future job, which the idempotent handler absorbs.
+*/
+const deletePendingCloseJobs = async (payload, formId, req) => {
+	try {
+		await payload.db.deleteMany({
+			collection: JOBS_SLUG,
+			req,
+			where: { and: [
+				{ completedAt: { exists: false } },
+				{ processing: { equals: false } },
+				{ taskSlug: { equals: POLL_CLOSE_TASK_SLUG } },
+				{ "input.formId": { equals: String(formId) } }
+			] }
+		});
+	} catch (error) {
+		payload.logger?.error(`@10x-media/form-builder: failed to clear pending poll-close jobs for form ${String(formId)}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+/**
+* Schedule (or reschedule) the auto-close for a poll after a save. Enqueues a `waitUntil: closesAt`
+* job when the poll is enabled, has a `closesAt`, is still unresolved, and its strategy is not
+* `manual`, and only when a job runner is present (`payload.jobs.queue`); otherwise the resolve-on-read
+* fallback is the safety net. Any prior pending close job for the form is deleted first so the newest
+* `closesAt` wins. Never throws; a queue failure is logged and swallowed.
+*/
+const enqueuePollClose = async (args) => {
+	const { payload, form, req } = args;
+	const poll = pollConfigOf(form.poll);
+	if (form.pollEnabled !== true || !poll) return;
+	const closesAt = typeof poll.closesAt === "string" && poll.closesAt.length > 0 ? poll.closesAt : void 0;
+	if (!closesAt || !hasEmptyWinners(poll) || strategyOf(poll) === "manual" || !canQueue(payload)) return;
+	const waitUntil = new Date(closesAt);
+	if (Number.isNaN(waitUntil.getTime())) return;
+	await deletePendingCloseJobs(payload, form.id, req);
+	try {
+		await payload.jobs.queue({
+			task: POLL_CLOSE_TASK_SLUG,
+			input: { formId: String(form.id) },
+			waitUntil,
+			req
+		});
+	} catch (error) {
+		payload.logger?.error(`@10x-media/form-builder: failed to enqueue poll-close for form ${String(form.id)}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+//#endregion
+export { POLL_CLOSE_TASK_SLUG, buildPollCloseTask, enqueuePollClose, registerPollCloseTask, runPollClose, shouldAutoResolvePoll };
+
+//# sourceMappingURL=closeJob.js.map

package/dist/poll/closeJob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"closeJob.js","names":[],"sources":["../../src/poll/closeJob.ts"],"sourcesContent":["import type { Config, Payload, PayloadRequest, TaskConfig } from 'payload'\nimport { FORMS_SLUG } from '../collections/forms'\nimport { isPollClosed, type PollConfigLike, pollConfigOf } from '../form/pollState'\nimport { resolvePollOutcome } from './resolvePollOutcome'\n\nexport const POLL_CLOSE_TASK_SLUG = 'form-builder-poll-close'\n\n/** Payload's jobs collection; queried directly to supersede a superseded pending close job. */\nconst JOBS_SLUG = 'payload-jobs'\n\n/** Input the enqueue path stores; the handler re-loads everything else from the DB. */\nexport type PollCloseTaskInput = { formId: number | string }\n\n/** The slice of a loaded form the close gate reads. */\nexport type PollFormLike = { pollEnabled?: boolean | null; poll?: unknown }\n\nconst hasEmptyWinners = (poll: PollConfigLike): boolean => {\n\tconst winners = poll.outcome?.winningValues\n\treturn (\n\t\t!Array.isArray(winners) ||\n\t\twinners.filter((value) => typeof value === 'string' && value.length > 0).length === 0\n\t)\n}\n\nconst strategyOf = (poll: PollConfigLike): string =>\n\ttypeof poll.type === 'string' && poll.type.length > 0 ? poll.type : 'manual'\n\n/**\n * True when a poll's outcome should auto-resolve now: enabled, closed, still unresolved, and its\n * strategy is not `manual`. Shared by the close-job handler and the results-read fallback so the two\n * triggers apply the exact same gate.\n */\nexport const shouldAutoResolvePoll = (form: PollFormLike): boolean => {\n\tconst poll = pollConfigOf(form.poll)\n\treturn (\n\t\tform.pollEnabled === true &&\n\t\tpoll != null &&\n\t\tisPollClosed(poll) &&\n\t\thasEmptyWinners(poll) &&\n\t\tstrategyOf(poll) !== 'manual'\n\t)\n}\n\n/**\n * Run the scheduled close for one form. Idempotent: re-loads the form and only resolves when the\n * poll is enabled, closed, still unresolved, and not `manual`, so a re-run after the outcome was\n * recorded (or a job that fires slightly early) is a safe no-op. Tolerates a deleted form.\n */\nexport const runPollClose = async (args: {\n\tpayload: Payload\n\tinput: PollCloseTaskInput\n\t/** Whether the hidden tally store backs the outcome aggregation (see `resolvePollOutcome`). */\n\tpollVotesEnabled?: boolean\n\treq?: PayloadRequest\n}): Promise<void> => {\n\tconst { payload, input, pollVotesEnabled, req } = args\n\tconst form = await payload\n\t\t.findByID({ collection: FORMS_SLUG, id: input.formId, depth: 0, overrideAccess: true, req })\n\t\t.catch(() => null)\n\tif (!form || !shouldAutoResolvePoll(form as PollFormLike)) {\n\t\treturn\n\t}\n\tawait resolvePollOutcome({ payload, formId: input.formId, pollVotesEnabled, req })\n}\n\n/** Native Payload jobs task that resolves a poll's outcome once it closes. */\nexport const buildPollCloseTask = (pollVotesEnabled = false): TaskConfig =>\n\t({\n\t\tslug: POLL_CLOSE_TASK_SLUG,\n\t\tinputSchema: [{ name: 'formId', type: 'text', required: true }],\n\t\thandler: async ({ input, req }) => {\n\t\t\tawait runPollClose({\n\t\t\t\tpayload: req.payload,\n\t\t\t\tinput: input as PollCloseTaskInput,\n\t\t\t\tpollVotesEnabled,\n\t\t\t\treq,\n\t\t\t})\n\t\t\treturn { output: {} }\n\t\t},\n\t}) as TaskConfig\n\n/** Register the poll-close task on `config.jobs.tasks`, creating the jobs config if absent. */\nexport const registerPollCloseTask = (config: Config, pollVotesEnabled = false): void => {\n\tconfig.jobs ??= {}\n\tconfig.jobs.tasks ??= []\n\tconfig.jobs.tasks.push(buildPollCloseTask(pollVotesEnabled))\n}\n\nconst canQueue = (payload: Payload): boolean => typeof payload.jobs?.queue === 'function'\n\n/**\n * Delete this form's pending (never-run) close jobs so a re-enqueue supersedes the prior one. Payload\n * 3.85's `jobs.queue` has no concurrency key, so this mirrors core's `deleteScheduledPublishJobs`:\n * a direct `db.deleteMany` on the jobs collection, scoped by task slug and the JSON `input.formId`.\n * Best-effort; a failure here only risks a duplicate future job, which the idempotent handler absorbs.\n */\nconst deletePendingCloseJobs = async (\n\tpayload: Payload,\n\tformId: number | string,\n\treq?: PayloadRequest\n): Promise<void> => {\n\ttry {\n\t\tawait payload.db.deleteMany({\n\t\t\tcollection: JOBS_SLUG,\n\t\t\treq,\n\t\t\twhere: {\n\t\t\t\tand: [\n\t\t\t\t\t{ completedAt: { exists: false } },\n\t\t\t\t\t{ processing: { equals: false } },\n\t\t\t\t\t{ taskSlug: { equals: POLL_CLOSE_TASK_SLUG } },\n\t\t\t\t\t{ 'input.formId': { equals: String(formId) } },\n\t\t\t\t],\n\t\t\t},\n\t\t})\n\t} catch (error) {\n\t\tpayload.logger?.error(\n\t\t\t`@10x-media/form-builder: failed to clear pending poll-close jobs for form ${String(formId)}: ${\n\t\t\t\terror instanceof Error ? error.message : String(error)\n\t\t\t}`\n\t\t)\n\t}\n}\n\n/**\n * Schedule (or reschedule) the auto-close for a poll after a save. Enqueues a `waitUntil: closesAt`\n * job when the poll is enabled, has a `closesAt`, is still unresolved, and its strategy is not\n * `manual`, and only when a job runner is present (`payload.jobs.queue`); otherwise the resolve-on-read\n * fallback is the safety net. Any prior pending close job for the form is deleted first so the newest\n * `closesAt` wins. Never throws; a queue failure is logged and swallowed.\n */\nexport const enqueuePollClose = async (args: {\n\tpayload: Payload\n\tform: { id: number | string; pollEnabled?: boolean | null; poll?: unknown }\n\treq?: PayloadRequest\n}): Promise<void> => {\n\tconst { payload, form, req } = args\n\tconst poll = pollConfigOf(form.poll)\n\tif (form.pollEnabled !== true || !poll) {\n\t\treturn\n\t}\n\tconst closesAt =\n\t\ttypeof poll.closesAt === 'string' && poll.closesAt.length > 0 ? poll.closesAt : undefined\n\tif (!closesAt || !hasEmptyWinners(poll) || strategyOf(poll) === 'manual' || !canQueue(payload)) {\n\t\treturn\n\t}\n\tconst waitUntil = new Date(closesAt)\n\tif (Number.isNaN(waitUntil.getTime())) {\n\t\treturn\n\t}\n\tawait deletePendingCloseJobs(payload, form.id, req)\n\ttry {\n\t\tawait payload.jobs.queue({\n\t\t\ttask: POLL_CLOSE_TASK_SLUG,\n\t\t\tinput: { formId: String(form.id) },\n\t\t\twaitUntil,\n\t\t\treq,\n\t\t})\n\t} catch (error) {\n\t\tpayload.logger?.error(\n\t\t\t`@10x-media/form-builder: failed to enqueue poll-close for form ${String(form.id)}: ${\n\t\t\t\terror instanceof Error ? error.message : String(error)\n\t\t\t}`\n\t\t)\n\t}\n}\n"],"mappings":"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"}

package/dist/poll/definePollOptionSource.d.ts

@@ -0,0 +1,44 @@
+import { Field, Payload, PayloadRequest } from "payload";
+
+//#region src/poll/definePollOptionSource.d.ts
+/** One selectable poll choice. `value` is the host's stable identifier contract: it is stored in submissions and later matched against `outcome.winningValues`, so it must never change once votes exist. */
+type PollOption = {
+  label: string;
+  value: string;
+};
+type PollOptionResolveArgs<TConfig extends Record<string, unknown> = Record<string, unknown>> = {
+  config: TConfig;
+  form: {
+    id: number | string;
+    title?: string;
+  };
+  payload: Payload;
+  req?: PayloadRequest;
+};
+/**
+ * A poll option source type, authored once by the host: `config` is the admin `Field[]` an author
+ * fills per form (e.g. an event id); `resolve` maps that config to the current options from host
+ * domain data. Called at render time (via `resolvePollOptions`) and again at submission time, where
+ * the resolved values are the only accepted answers (fail closed).
+ */
+type PollOptionSource<TConfig extends Record<string, unknown> = Record<string, unknown>> = {
+  type: string; /** i18n-key or literal (resolved like a field label), or a per-locale record. */
+  label: string | Record<string, string>;
+  config?: Field[];
+  resolve: (args: PollOptionResolveArgs<TConfig>) => Promise<PollOption[]> | PollOption[];
+  /**
+   * Optional outcome resolver: return the winning option value(s) from domain data (e.g. the
+   * recorded race result), a `string[]` when the result is a tie, or `undefined` while the outcome
+   * is not yet decidable. Backs the built-in `source` poll type, so a form whose `poll.type` is
+   * `source` auto-resolves through it (via the scheduled close job, a results-read, or an explicit
+   * `resolvePollOutcome({ payload, formId })`); every returned value is validated against the poll's
+   * resolved options before it is recorded, so each must be one of the values `resolve` yields.
+   */
+  resolveOutcome?: (args: PollOptionResolveArgs<TConfig>) => Promise<string | string[] | undefined> | string | string[] | undefined;
+};
+/** Erased shape stored in the registry; config re-narrows per matched type at resolution. */
+type AnyPollOptionSource = PollOptionSource<Record<string, unknown>>;
+declare const definePollOptionSource: <TConfig extends Record<string, unknown> = Record<string, unknown>>(source: PollOptionSource<TConfig>) => PollOptionSource<TConfig>;
+//#endregion
+export { AnyPollOptionSource, PollOption, PollOptionResolveArgs, PollOptionSource, definePollOptionSource };
+//# sourceMappingURL=definePollOptionSource.d.ts.map

package/dist/poll/definePollOptionSource.js

@@ -0,0 +1,6 @@
+//#region src/poll/definePollOptionSource.ts
+const definePollOptionSource = (source) => source;
+//#endregion
+export { definePollOptionSource };
+
+//# sourceMappingURL=definePollOptionSource.js.map

package/dist/poll/definePollOptionSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definePollOptionSource.js","names":[],"sources":["../../src/poll/definePollOptionSource.ts"],"sourcesContent":["import type { Field, Payload, PayloadRequest } from 'payload'\n\n/** One selectable poll choice. `value` is the host's stable identifier contract: it is stored in submissions and later matched against `outcome.winningValues`, so it must never change once votes exist. */\nexport type PollOption = { label: string; value: string }\n\nexport type PollOptionResolveArgs<\n\tTConfig extends Record<string, unknown> = Record<string, unknown>,\n> = {\n\tconfig: TConfig\n\tform: { id: number | string; title?: string }\n\tpayload: Payload\n\treq?: PayloadRequest\n}\n\n/**\n * A poll option source type, authored once by the host: `config` is the admin `Field[]` an author\n * fills per form (e.g. an event id); `resolve` maps that config to the current options from host\n * domain data. Called at render time (via `resolvePollOptions`) and again at submission time, where\n * the resolved values are the only accepted answers (fail closed).\n */\nexport type PollOptionSource<TConfig extends Record<string, unknown> = Record<string, unknown>> = {\n\ttype: string\n\t/** i18n-key or literal (resolved like a field label), or a per-locale record. */\n\tlabel: string | Record<string, string>\n\tconfig?: Field[]\n\tresolve: (args: PollOptionResolveArgs<TConfig>) => Promise<PollOption[]> | PollOption[]\n\t/**\n\t * Optional outcome resolver: return the winning option value(s) from domain data (e.g. the\n\t * recorded race result), a `string[]` when the result is a tie, or `undefined` while the outcome\n\t * is not yet decidable. Backs the built-in `source` poll type, so a form whose `poll.type` is\n\t * `source` auto-resolves through it (via the scheduled close job, a results-read, or an explicit\n\t * `resolvePollOutcome({ payload, formId })`); every returned value is validated against the poll's\n\t * resolved options before it is recorded, so each must be one of the values `resolve` yields.\n\t */\n\tresolveOutcome?: (\n\t\targs: PollOptionResolveArgs<TConfig>\n\t) => Promise<string | string[] | undefined> | string | string[] | undefined\n}\n\n/** Erased shape stored in the registry; config re-narrows per matched type at resolution. */\nexport type AnyPollOptionSource = PollOptionSource<Record<string, unknown>>\n\nexport const definePollOptionSource = <\n\tTConfig extends Record<string, unknown> = Record<string, unknown>,\n>(\n\tsource: PollOptionSource<TConfig>\n): PollOptionSource<TConfig> => source\n"],"mappings":";AA0CA,MAAa,0BAGZ,WAC+B"}

package/dist/poll/definePollType.d.ts

@@ -0,0 +1,34 @@
+import { FieldAggregation } from "../aggregation/types.js";
+import { PollConfigLike } from "../form/pollState.js";
+import { Field, Payload, PayloadRequest } from "payload";
+
+//#region src/poll/definePollType.d.ts
+type PollOutcomeStrategyArgs = {
+  payload: Payload;
+  req?: PayloadRequest; /** The loaded forms document, widened so a strategy can read host-owned members (e.g. `form.tenant`). */
+  form: {
+    id: number | string;
+    poll?: unknown;
+    fields?: unknown;
+  } & Record<string, unknown>; /** The poll config narrowed from the form via `pollConfigOf`. */
+  poll: PollConfigLike; /** Aggregate the poll's results field, memoized by the caller. Null when there is no results field or no data. */
+  aggregate: () => Promise<FieldAggregation | null>;
+};
+/**
+ * An outcome-resolution strategy for a poll, authored once and registered via the plugin `poll.types`
+ * option (built-ins `manual`, `mostVoted`, `source` are always registered). The poll's `type` select
+ * picks one; `resolvePollOutcome` runs it when no explicit `winningValues` are passed. `resolveOutcome`
+ * returns the winning value set, or `undefined` when the outcome is not yet decidable so nothing is
+ * written. Every returned value is still validated against the poll's effective options by
+ * `pollOutcomeBeforeChange`, so a strategy can never record a value outside the poll's choices.
+ */
+type PollOutcomeStrategy = {
+  type: string; /** i18n-key or literal (resolved like a field label), or a per-locale record. */
+  label: string | Record<string, string>;
+  config?: Field[];
+  resolveOutcome: (args: PollOutcomeStrategyArgs) => Promise<string[] | undefined> | string[] | undefined;
+};
+declare const definePollType: (strategy: PollOutcomeStrategy) => PollOutcomeStrategy;
+//#endregion
+export { PollOutcomeStrategy, PollOutcomeStrategyArgs, definePollType };
+//# sourceMappingURL=definePollType.d.ts.map

package/dist/poll/definePollType.js

@@ -0,0 +1,6 @@
+//#region src/poll/definePollType.ts
+const definePollType = (strategy) => strategy;
+//#endregion
+export { definePollType };
+
+//# sourceMappingURL=definePollType.js.map

package/dist/poll/definePollType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definePollType.js","names":[],"sources":["../../src/poll/definePollType.ts"],"sourcesContent":["import type { Field, Payload, PayloadRequest } from 'payload'\nimport type { FieldAggregation } from '../aggregation/types'\nimport type { PollConfigLike } from '../form/pollState'\n\nexport type PollOutcomeStrategyArgs = {\n\tpayload: Payload\n\treq?: PayloadRequest\n\t/** The loaded forms document, widened so a strategy can read host-owned members (e.g. `form.tenant`). */\n\tform: { id: number | string; poll?: unknown; fields?: unknown } & Record<string, unknown>\n\t/** The poll config narrowed from the form via `pollConfigOf`. */\n\tpoll: PollConfigLike\n\t/** Aggregate the poll's results field, memoized by the caller. Null when there is no results field or no data. */\n\taggregate: () => Promise<FieldAggregation | null>\n}\n\n/**\n * An outcome-resolution strategy for a poll, authored once and registered via the plugin `poll.types`\n * option (built-ins `manual`, `mostVoted`, `source` are always registered). The poll's `type` select\n * picks one; `resolvePollOutcome` runs it when no explicit `winningValues` are passed. `resolveOutcome`\n * returns the winning value set, or `undefined` when the outcome is not yet decidable so nothing is\n * written. Every returned value is still validated against the poll's effective options by\n * `pollOutcomeBeforeChange`, so a strategy can never record a value outside the poll's choices.\n */\nexport type PollOutcomeStrategy = {\n\ttype: string\n\t/** i18n-key or literal (resolved like a field label), or a per-locale record. */\n\tlabel: string | Record<string, string>\n\tconfig?: Field[]\n\tresolveOutcome: (\n\t\targs: PollOutcomeStrategyArgs\n\t) => Promise<string[] | undefined> | string[] | undefined\n}\n\nexport const definePollType = (strategy: PollOutcomeStrategy): PollOutcomeStrategy => strategy\n"],"mappings":";AAiCA,MAAa,kBAAkB,aAAuD"}

package/dist/poll/effectivePollOptions.d.ts

@@ -0,0 +1,38 @@
+import { PollOption } from "./definePollOptionSource.js";
+import { FieldTypeRegistry } from "../fields/registry.js";
+import { PollOptionSourceRegistry } from "./registry.js";
+import { Payload, PayloadRequest } from "payload";
+
+//#region src/poll/effectivePollOptions.d.ts
+type ResolveEffectivePollOptionsArgs = {
+  payload: Payload;
+  req?: PayloadRequest; /** A forms document (or an equivalent merged view of one during a save). */
+  form: {
+    id: number | string;
+    title?: string | null; /** Top-level poll-enable flag; the poll config (results field, source) stays under `poll`. */
+    pollEnabled?: boolean | null;
+    poll?: unknown;
+    fields?: unknown;
+  }; /** Registry override for plugin-internal callers; defaults to the registry stashed on the config. */
+  sources?: PollOptionSourceRegistry;
+  /**
+   * Field-type registry override; defaults to the one stashed on the config. Lets the results
+   * field's definition source its own options via {@link FormFieldDefinition.resolveOptions}.
+   */
+  fieldTypes?: FieldTypeRegistry;
+};
+/**
+ * The poll's currently valid choice set, resolved in a fixed precedence: source-resolved options
+ * when the poll has an `optionSource`, else the results field type's own {@link
+ * FormFieldDefinition.resolveOptions} when it declares one (given the live field instance so a
+ * custom type can enumerate the values it holds), else the authored options of the field instance.
+ * Empty when the poll is disabled, no results field is set, or none of the branches yields options.
+ * This single set backs both the admin winner select (the `/:id/poll-options` endpoint) and outcome
+ * membership validation, so what the admin offers and what the server accepts cannot drift. Source
+ * and resolver failures propagate so callers fail closed; the resolver branch is cached per request
+ * (keyed by form id) when a `req` is provided, matching the source path.
+ */
+declare const resolveEffectivePollOptions: (args: ResolveEffectivePollOptionsArgs) => Promise<PollOption[]>;
+//#endregion
+export { ResolveEffectivePollOptionsArgs, resolveEffectivePollOptions };
+//# sourceMappingURL=effectivePollOptions.d.ts.map

package/dist/poll/effectivePollOptions.js

@@ -0,0 +1,64 @@
+import { fieldTypesOf } from "../fields/registry.js";
+import { pollConfigOf } from "../form/pollState.js";
+import { instanceOptionsOf } from "../fields/instanceOptions.js";
+import { resolvePollOptions } from "./resolvePollOptions.js";
+//#region src/poll/effectivePollOptions.ts
+const CACHE_KEY = "formBuilderFieldOptionsCache";
+const cacheOf = (req) => {
+	if (!req?.context) return;
+	const existing = req.context[CACHE_KEY];
+	if (existing instanceof Map) return existing;
+	const created = /* @__PURE__ */ new Map();
+	req.context[CACHE_KEY] = created;
+	return created;
+};
+/**
+* The poll's currently valid choice set, resolved in a fixed precedence: source-resolved options
+* when the poll has an `optionSource`, else the results field type's own {@link
+* FormFieldDefinition.resolveOptions} when it declares one (given the live field instance so a
+* custom type can enumerate the values it holds), else the authored options of the field instance.
+* Empty when the poll is disabled, no results field is set, or none of the branches yields options.
+* This single set backs both the admin winner select (the `/:id/poll-options` endpoint) and outcome
+* membership validation, so what the admin offers and what the server accepts cannot drift. Source
+* and resolver failures propagate so callers fail closed; the resolver branch is cached per request
+* (keyed by form id) when a `req` is provided, matching the source path.
+*/
+const resolveEffectivePollOptions = async (args) => {
+	const { payload, req, form, sources, fieldTypes } = args;
+	const poll = pollConfigOf(form.poll);
+	if (form.pollEnabled !== true || !poll) return [];
+	const sourced = await resolvePollOptions({
+		payload,
+		req,
+		form,
+		sources
+	});
+	if (sourced) return sourced;
+	const resultsField = typeof poll.resultsField === "string" && poll.resultsField.length > 0 ? poll.resultsField : void 0;
+	if (!resultsField) return [];
+	const instance = (Array.isArray(form.fields) ? form.fields : []).find((entry) => entry.name === resultsField);
+	if (!instance) return [];
+	const definition = (fieldTypes ?? fieldTypesOf(payload)).get(instance.blockType);
+	if (definition?.resolveOptions) {
+		const cache = cacheOf(req);
+		const cacheKey = String(form.id);
+		const cached = cache?.get(cacheKey);
+		if (cached) return cached;
+		const options = await definition.resolveOptions({
+			instance,
+			form: {
+				id: form.id,
+				title: typeof form.title === "string" ? form.title : void 0
+			},
+			payload,
+			req
+		});
+		cache?.set(cacheKey, options);
+		return options;
+	}
+	return instanceOptionsOf(instance) ?? [];
+};
+//#endregion
+export { resolveEffectivePollOptions };
+
+//# sourceMappingURL=effectivePollOptions.js.map

package/dist/poll/effectivePollOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectivePollOptions.js","names":[],"sources":["../../src/poll/effectivePollOptions.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from 'payload'\nimport { instanceOptionsOf } from '../fields/instanceOptions'\nimport { type FieldTypeRegistry, fieldTypesOf } from '../fields/registry'\nimport { pollConfigOf } from '../form/pollState'\nimport type { FormFieldInstance } from '../submissions/types'\nimport type { PollOption } from './definePollOptionSource'\nimport type { PollOptionSourceRegistry } from './registry'\nimport { resolvePollOptions } from './resolvePollOptions'\n\nexport type ResolveEffectivePollOptionsArgs = {\n\tpayload: Payload\n\treq?: PayloadRequest\n\t/** A forms document (or an equivalent merged view of one during a save). */\n\tform: {\n\t\tid: number | string\n\t\ttitle?: string | null\n\t\t/** Top-level poll-enable flag; the poll config (results field, source) stays under `poll`. */\n\t\tpollEnabled?: boolean | null\n\t\tpoll?: unknown\n\t\tfields?: unknown\n\t}\n\t/** Registry override for plugin-internal callers; defaults to the registry stashed on the config. */\n\tsources?: PollOptionSourceRegistry\n\t/**\n\t * Field-type registry override; defaults to the one stashed on the config. Lets the results\n\t * field's definition source its own options via {@link FormFieldDefinition.resolveOptions}.\n\t */\n\tfieldTypes?: FieldTypeRegistry\n}\n\nconst CACHE_KEY = 'formBuilderFieldOptionsCache'\n\ntype OptionsCache = Map<string, PollOption[]>\n\nconst cacheOf = (req: PayloadRequest | undefined): OptionsCache | undefined => {\n\tif (!req?.context) {\n\t\treturn undefined\n\t}\n\tconst existing = req.context[CACHE_KEY]\n\tif (existing instanceof Map) {\n\t\treturn existing as OptionsCache\n\t}\n\tconst created: OptionsCache = new Map()\n\treq.context[CACHE_KEY] = created\n\treturn created\n}\n\n/**\n * The poll's currently valid choice set, resolved in a fixed precedence: source-resolved options\n * when the poll has an `optionSource`, else the results field type's own {@link\n * FormFieldDefinition.resolveOptions} when it declares one (given the live field instance so a\n * custom type can enumerate the values it holds), else the authored options of the field instance.\n * Empty when the poll is disabled, no results field is set, or none of the branches yields options.\n * This single set backs both the admin winner select (the `/:id/poll-options` endpoint) and outcome\n * membership validation, so what the admin offers and what the server accepts cannot drift. Source\n * and resolver failures propagate so callers fail closed; the resolver branch is cached per request\n * (keyed by form id) when a `req` is provided, matching the source path.\n */\nexport const resolveEffectivePollOptions = async (\n\targs: ResolveEffectivePollOptionsArgs\n): Promise<PollOption[]> => {\n\tconst { payload, req, form, sources, fieldTypes } = args\n\tconst poll = pollConfigOf(form.poll)\n\tif (form.pollEnabled !== true || !poll) {\n\t\treturn []\n\t}\n\tconst sourced = await resolvePollOptions({ payload, req, form, sources })\n\tif (sourced) {\n\t\treturn sourced\n\t}\n\tconst resultsField =\n\t\ttypeof poll.resultsField === 'string' && poll.resultsField.length > 0\n\t\t\t? poll.resultsField\n\t\t\t: undefined\n\tif (!resultsField) {\n\t\treturn []\n\t}\n\tconst instances = Array.isArray(form.fields) ? (form.fields as FormFieldInstance[]) : []\n\tconst instance = instances.find((entry) => entry.name === resultsField)\n\tif (!instance) {\n\t\treturn []\n\t}\n\tconst definition = (fieldTypes ?? fieldTypesOf(payload)).get(instance.blockType)\n\tif (definition?.resolveOptions) {\n\t\tconst cache = cacheOf(req)\n\t\tconst cacheKey = String(form.id)\n\t\tconst cached = cache?.get(cacheKey)\n\t\tif (cached) {\n\t\t\treturn cached\n\t\t}\n\t\tconst options = await definition.resolveOptions({\n\t\t\tinstance,\n\t\t\tform: { id: form.id, title: typeof form.title === 'string' ? form.title : undefined },\n\t\t\tpayload,\n\t\t\treq,\n\t\t})\n\t\tcache?.set(cacheKey, options)\n\t\treturn options\n\t}\n\treturn instanceOptionsOf(instance) ?? []\n}\n"],"mappings":";;;;;AA8BA,MAAM,YAAY;AAIlB,MAAM,WAAW,QAA8D;CAC9E,IAAI,CAAC,KAAK,SACT;CAED,MAAM,WAAW,IAAI,QAAQ;CAC7B,IAAI,oBAAoB,KACvB,OAAO;CAER,MAAM,0BAAwB,IAAI,IAAI;CACtC,IAAI,QAAQ,aAAa;CACzB,OAAO;AACR;;;;;;;;;;;;AAaA,MAAa,8BAA8B,OAC1C,SAC2B;CAC3B,MAAM,EAAE,SAAS,KAAK,MAAM,SAAS,eAAe;CACpD,MAAM,OAAO,aAAa,KAAK,IAAI;CACnC,IAAI,KAAK,gBAAgB,QAAQ,CAAC,MACjC,OAAO,CAAC;CAET,MAAM,UAAU,MAAM,mBAAmB;EAAE;EAAS;EAAK;EAAM;CAAQ,CAAC;CACxE,IAAI,SACH,OAAO;CAER,MAAM,eACL,OAAO,KAAK,iBAAiB,YAAY,KAAK,aAAa,SAAS,IACjE,KAAK,eACL,KAAA;CACJ,IAAI,CAAC,cACJ,OAAO,CAAC;CAGT,MAAM,YADY,MAAM,QAAQ,KAAK,MAAM,IAAK,KAAK,SAAiC,CAAC,GAC5D,MAAM,UAAU,MAAM,SAAS,YAAY;CACtE,IAAI,CAAC,UACJ,OAAO,CAAC;CAET,MAAM,cAAc,cAAc,aAAa,OAAO,GAAG,IAAI,SAAS,SAAS;CAC/E,IAAI,YAAY,gBAAgB;EAC/B,MAAM,QAAQ,QAAQ,GAAG;EACzB,MAAM,WAAW,OAAO,KAAK,EAAE;EAC/B,MAAM,SAAS,OAAO,IAAI,QAAQ;EAClC,IAAI,QACH,OAAO;EAER,MAAM,UAAU,MAAM,WAAW,eAAe;GAC/C;GACA,MAAM;IAAE,IAAI,KAAK;IAAI,OAAO,OAAO,KAAK,UAAU,WAAW,KAAK,QAAQ,KAAA;GAAU;GACpF;GACA;EACD,CAAC;EACD,OAAO,IAAI,UAAU,OAAO;EAC5B,OAAO;CACR;CACA,OAAO,kBAAkB,QAAQ,KAAK,CAAC;AACxC"}

package/dist/poll/mostVoted.d.ts

@@ -0,0 +1,21 @@
+import { PollOutcomeStrategy } from "./definePollType.js";
+
+//#region src/poll/mostVoted.d.ts
+/**
+ * Every bucket value tied for the highest count, so a draw records all co-winners. Empty when there
+ * are no buckets. Pure: the caller decides whether the aggregation is trustworthy enough to act on.
+ */
+declare const topBucketValues: (buckets: {
+  value: string;
+  count: number;
+}[]) => string[];
+/**
+ * Auto-resolve to whichever choice(s) received the most votes. Refuses to decide, returning
+ * `undefined` (no write), when there is no aggregation, no responses yet, or the aggregation was
+ * `truncated` (a sample cannot be trusted to name the true winner, so it is flagged for a manual
+ * call instead). A perfect tie records every co-winner.
+ */
+declare const mostVotedStrategy: PollOutcomeStrategy;
+//#endregion
+export { mostVotedStrategy, topBucketValues };
+//# sourceMappingURL=mostVoted.d.ts.map

package/dist/poll/mostVoted.js

@@ -0,0 +1,32 @@
+import { keys } from "../translations/keys.js";
+import { definePollType } from "./definePollType.js";
+//#region src/poll/mostVoted.ts
+/**
+* Every bucket value tied for the highest count, so a draw records all co-winners. Empty when there
+* are no buckets. Pure: the caller decides whether the aggregation is trustworthy enough to act on.
+*/
+const topBucketValues = (buckets) => {
+	if (buckets.length === 0) return [];
+	const max = Math.max(...buckets.map((bucket) => bucket.count));
+	return buckets.filter((bucket) => bucket.count === max).map((bucket) => bucket.value);
+};
+/**
+* Auto-resolve to whichever choice(s) received the most votes. Refuses to decide, returning
+* `undefined` (no write), when there is no aggregation, no responses yet, or the aggregation was
+* `truncated` (a sample cannot be trusted to name the true winner, so it is flagged for a manual
+* call instead). A perfect tie records every co-winner.
+*/
+const mostVotedStrategy = definePollType({
+	type: "mostVoted",
+	label: keys.pollTypeMostVoted,
+	resolveOutcome: async ({ aggregate }) => {
+		const aggregation = await aggregate();
+		if (!aggregation || aggregation.total === 0 || aggregation.truncated) return;
+		const winners = topBucketValues(aggregation.buckets);
+		return winners.length > 0 ? winners : void 0;
+	}
+});
+//#endregion
+export { mostVotedStrategy, topBucketValues };
+
+//# sourceMappingURL=mostVoted.js.map

package/dist/poll/mostVoted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mostVoted.js","names":[],"sources":["../../src/poll/mostVoted.ts"],"sourcesContent":["import { keys } from '../translations/keys'\nimport { definePollType, type PollOutcomeStrategy } from './definePollType'\n\n/**\n * Every bucket value tied for the highest count, so a draw records all co-winners. Empty when there\n * are no buckets. Pure: the caller decides whether the aggregation is trustworthy enough to act on.\n */\nexport const topBucketValues = (buckets: { value: string; count: number }[]): string[] => {\n\tif (buckets.length === 0) {\n\t\treturn []\n\t}\n\tconst max = Math.max(...buckets.map((bucket) => bucket.count))\n\treturn buckets.filter((bucket) => bucket.count === max).map((bucket) => bucket.value)\n}\n\n/**\n * Auto-resolve to whichever choice(s) received the most votes. Refuses to decide, returning\n * `undefined` (no write), when there is no aggregation, no responses yet, or the aggregation was\n * `truncated` (a sample cannot be trusted to name the true winner, so it is flagged for a manual\n * call instead). A perfect tie records every co-winner.\n */\nexport const mostVotedStrategy: PollOutcomeStrategy = definePollType({\n\ttype: 'mostVoted',\n\tlabel: keys.pollTypeMostVoted,\n\tresolveOutcome: async ({ aggregate }) => {\n\t\tconst aggregation = await aggregate()\n\t\tif (!aggregation || aggregation.total === 0 || aggregation.truncated) {\n\t\t\treturn undefined\n\t\t}\n\t\tconst winners = topBucketValues(aggregation.buckets)\n\t\treturn winners.length > 0 ? winners : undefined\n\t},\n})\n"],"mappings":";;;;;;;AAOA,MAAa,mBAAmB,YAA0D;CACzF,IAAI,QAAQ,WAAW,GACtB,OAAO,CAAC;CAET,MAAM,MAAM,KAAK,IAAI,GAAG,QAAQ,KAAK,WAAW,OAAO,KAAK,CAAC;CAC7D,OAAO,QAAQ,QAAQ,WAAW,OAAO,UAAU,GAAG,EAAE,KAAK,WAAW,OAAO,KAAK;AACrF;;;;;;;AAQA,MAAa,oBAAyC,eAAe;CACpE,MAAM;CACN,OAAO,KAAK;CACZ,gBAAgB,OAAO,EAAE,gBAAgB;EACxC,MAAM,cAAc,MAAM,UAAU;EACpC,IAAI,CAAC,eAAe,YAAY,UAAU,KAAK,YAAY,WAC1D;EAED,MAAM,UAAU,gBAAgB,YAAY,OAAO;EACnD,OAAO,QAAQ,SAAS,IAAI,UAAU,KAAA;CACvC;AACD,CAAC"}

package/dist/poll/outcomeBeforeChange.js

@@ -0,0 +1,91 @@
+import { keys } from "../translations/keys.js";
+import { asTranslate } from "../translations/server.js";
+import { pollConfigOf } from "../form/pollState.js";
+import { resolveEffectivePollOptions } from "./effectivePollOptions.js";
+import { FORMS_SLUG } from "../collections/forms.js";
+import { ValidationError } from "payload";
+//#region src/poll/outcomeBeforeChange.ts
+const WINNING_VALUES_PATH = "poll.outcome.winningValues";
+/** The winning set as a deduped array of non-empty strings, ready to store and to compare. */
+const normalizeWinning = (value) => {
+	if (!Array.isArray(value)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of value) if (typeof entry === "string" && entry.length > 0) seen.add(entry);
+	return [...seen];
+};
+/** Set equality on two already-deduped winner arrays: order-insensitive membership. */
+const sameWinners = (a, b) => {
+	if (a.length !== b.length) return false;
+	const set = new Set(a);
+	return b.every((value) => set.has(value));
+};
+/**
+* Owns the poll outcome lifecycle for every create and update, admin and API alike. When the save
+* writes `poll.outcome.winningValues` it validates a set or changed winner set against the poll's
+* effective options (source-resolved or authored, over a merged view of the doc so partial updates
+* validate against stored config) and requires the poll to be enabled; clearing is always allowed.
+* A tie is a set with more than one winner; every value must be a member of the effective options.
+*
+* It is also the single `resolvedAt` stamping point: stamped when the winner set is set or changed,
+* cleared with the set, untouched when the set is unchanged (order-insensitive). Callers can never
+* write `resolvedAt` themselves (field-level access strips it during the beforeValidate traversal,
+* before this hook runs), while values this hook sets survive to the database, so the stamp always
+* reflects the actual transition regardless of the write path.
+*/
+const pollOutcomeBeforeChange = async ({ data, originalDoc, req }) => {
+	const incomingPoll = data?.poll != null && typeof data.poll === "object" ? data.poll : void 0;
+	const outcome = incomingPoll?.outcome != null && typeof incomingPoll.outcome === "object" ? incomingPoll.outcome : void 0;
+	if (!outcome || !("winningValues" in outcome)) return data;
+	const next = normalizeWinning(outcome.winningValues);
+	outcome.winningValues = next;
+	if (sameWinners(next, normalizeWinning(pollConfigOf(originalDoc?.poll)?.outcome?.winningValues))) return data;
+	if (next.length === 0) {
+		outcome.resolvedAt = null;
+		return data;
+	}
+	const t = asTranslate(req.t);
+	const fail = (message) => {
+		throw new ValidationError({
+			collection: FORMS_SLUG,
+			errors: [{
+				path: WINNING_VALUES_PATH,
+				message
+			}]
+		}, req.t);
+	};
+	const mergedPoll = {
+		...(originalDoc?.poll != null && typeof originalDoc.poll === "object" ? originalDoc.poll : void 0) ?? {},
+		...incomingPoll
+	};
+	const mergedPollEnabled = {
+		...originalDoc ?? {},
+		...data
+	}.pollEnabled === true;
+	if (!mergedPollEnabled) fail(t(keys.validationWinningValueDisabled));
+	const id = originalDoc?.id ?? data?.id;
+	const form = {
+		id: id ?? "",
+		title: typeof data?.title === "string" ? data.title : originalDoc?.title,
+		pollEnabled: mergedPollEnabled,
+		poll: mergedPoll,
+		fields: data?.fields ?? originalDoc?.fields
+	};
+	let options;
+	try {
+		options = await resolveEffectivePollOptions({
+			payload: req.payload,
+			req: id != null ? req : void 0,
+			form
+		});
+	} catch {
+		return fail(t(keys.pollOptionsUnavailable));
+	}
+	const allowed = new Set(options.map((option) => option.value));
+	if (!next.every((value) => allowed.has(value))) fail(t(keys.validationWinningValueUnknown));
+	outcome.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+	return data;
+};
+//#endregion
+export { pollOutcomeBeforeChange };
+
+//# sourceMappingURL=outcomeBeforeChange.js.map