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

package/dist/poll/outcomeBeforeChange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcomeBeforeChange.js","names":[],"sources":["../../src/poll/outcomeBeforeChange.ts"],"sourcesContent":["import { type CollectionBeforeChangeHook, ValidationError } from 'payload'\nimport { FORMS_SLUG } from '../collections/forms'\nimport { pollConfigOf } from '../form/pollState'\nimport { keys } from '../translations/keys'\nimport { asTranslate } from '../translations/server'\nimport type { PollOption } from './definePollOptionSource'\nimport { resolveEffectivePollOptions } from './effectivePollOptions'\n\nconst WINNING_VALUES_PATH = 'poll.outcome.winningValues'\n\n/** The winning set as a deduped array of non-empty strings, ready to store and to compare. */\nconst normalizeWinning = (value: unknown): string[] => {\n\tif (!Array.isArray(value)) {\n\t\treturn []\n\t}\n\tconst seen = new Set<string>()\n\tfor (const entry of value) {\n\t\tif (typeof entry === 'string' && entry.length > 0) {\n\t\t\tseen.add(entry)\n\t\t}\n\t}\n\treturn [...seen]\n}\n\n/** Set equality on two already-deduped winner arrays: order-insensitive membership. */\nconst sameWinners = (a: string[], b: string[]): boolean => {\n\tif (a.length !== b.length) {\n\t\treturn false\n\t}\n\tconst set = new Set(a)\n\treturn b.every((value) => set.has(value))\n}\n\n/**\n * Owns the poll outcome lifecycle for every create and update, admin and API alike. When the save\n * writes `poll.outcome.winningValues` it validates a set or changed winner set against the poll's\n * effective options (source-resolved or authored, over a merged view of the doc so partial updates\n * validate against stored config) and requires the poll to be enabled; clearing is always allowed.\n * A tie is a set with more than one winner; every value must be a member of the effective options.\n *\n * It is also the single `resolvedAt` stamping point: stamped when the winner set is set or changed,\n * cleared with the set, untouched when the set is unchanged (order-insensitive). Callers can never\n * write `resolvedAt` themselves (field-level access strips it during the beforeValidate traversal,\n * before this hook runs), while values this hook sets survive to the database, so the stamp always\n * reflects the actual transition regardless of the write path.\n */\nexport const pollOutcomeBeforeChange: CollectionBeforeChangeHook = async ({\n\tdata,\n\toriginalDoc,\n\treq,\n}) => {\n\tconst incomingPoll =\n\t\tdata?.poll != null && typeof data.poll === 'object'\n\t\t\t? (data.poll as Record<string, unknown>)\n\t\t\t: undefined\n\tconst outcome =\n\t\tincomingPoll?.outcome != null && typeof incomingPoll.outcome === 'object'\n\t\t\t? (incomingPoll.outcome as Record<string, unknown>)\n\t\t\t: undefined\n\tif (!outcome || !('winningValues' in outcome)) {\n\t\treturn data\n\t}\n\tconst next = normalizeWinning(outcome.winningValues)\n\toutcome.winningValues = next\n\tconst previous = normalizeWinning(pollConfigOf(originalDoc?.poll)?.outcome?.winningValues)\n\tif (sameWinners(next, previous)) {\n\t\treturn data\n\t}\n\tif (next.length === 0) {\n\t\toutcome.resolvedAt = null\n\t\treturn data\n\t}\n\n\tconst t = asTranslate(req.t)\n\tconst fail = (message: string): never => {\n\t\tthrow new ValidationError(\n\t\t\t{ collection: FORMS_SLUG, errors: [{ path: WINNING_VALUES_PATH, message }] },\n\t\t\treq.t\n\t\t)\n\t}\n\tconst originalPoll =\n\t\toriginalDoc?.poll != null && typeof originalDoc.poll === 'object'\n\t\t\t? (originalDoc.poll as Record<string, unknown>)\n\t\t\t: undefined\n\tconst mergedPoll = { ...(originalPoll ?? {}), ...incomingPoll }\n\t// The poll-enable flag lives at the document root now; merge the incoming partial over the stored\n\t// doc so a partial update that omits it still validates against the persisted value.\n\tconst mergedPollEnabled = { ...(originalDoc ?? {}), ...data }.pollEnabled === true\n\tif (!mergedPollEnabled) {\n\t\tfail(t(keys.validationWinningValueDisabled))\n\t}\n\tconst id = (originalDoc?.id ?? data?.id) as number | string | undefined\n\tconst form = {\n\t\tid: id ?? '',\n\t\ttitle:\n\t\t\ttypeof data?.title === 'string' ? data.title : (originalDoc?.title as string | undefined),\n\t\tpollEnabled: mergedPollEnabled,\n\t\tpoll: mergedPoll,\n\t\tfields: data?.fields ?? originalDoc?.fields,\n\t}\n\tlet options: PollOption[]\n\ttry {\n\t\t// Without a doc id (create) the per-request options cache would key on '', so skip it.\n\t\toptions = await resolveEffectivePollOptions({\n\t\t\tpayload: req.payload,\n\t\t\treq: id != null ? req : undefined,\n\t\t\tform,\n\t\t})\n\t} catch {\n\t\treturn fail(t(keys.pollOptionsUnavailable))\n\t}\n\tconst allowed = new Set(options.map((option) => option.value))\n\tif (!next.every((value) => allowed.has(value))) {\n\t\tfail(t(keys.validationWinningValueUnknown))\n\t}\n\toutcome.resolvedAt = new Date().toISOString()\n\treturn data\n}\n"],"mappings":";;;;;;;AAQA,MAAM,sBAAsB;;AAG5B,MAAM,oBAAoB,UAA6B;CACtD,IAAI,CAAC,MAAM,QAAQ,KAAK,GACvB,OAAO,CAAC;CAET,MAAM,uBAAO,IAAI,IAAY;CAC7B,KAAK,MAAM,SAAS,OACnB,IAAI,OAAO,UAAU,YAAY,MAAM,SAAS,GAC/C,KAAK,IAAI,KAAK;CAGhB,OAAO,CAAC,GAAG,IAAI;AAChB;;AAGA,MAAM,eAAe,GAAa,MAAyB;CAC1D,IAAI,EAAE,WAAW,EAAE,QAClB,OAAO;CAER,MAAM,MAAM,IAAI,IAAI,CAAC;CACrB,OAAO,EAAE,OAAO,UAAU,IAAI,IAAI,KAAK,CAAC;AACzC;;;;;;;;;;;;;;AAeA,MAAa,0BAAsD,OAAO,EACzE,MACA,aACA,UACK;CACL,MAAM,eACL,MAAM,QAAQ,QAAQ,OAAO,KAAK,SAAS,WACvC,KAAK,OACN,KAAA;CACJ,MAAM,UACL,cAAc,WAAW,QAAQ,OAAO,aAAa,YAAY,WAC7D,aAAa,UACd,KAAA;CACJ,IAAI,CAAC,WAAW,EAAE,mBAAmB,UACpC,OAAO;CAER,MAAM,OAAO,iBAAiB,QAAQ,aAAa;CACnD,QAAQ,gBAAgB;CAExB,IAAI,YAAY,MADC,iBAAiB,aAAa,aAAa,IAAI,GAAG,SAAS,aAC/C,CAAC,GAC7B,OAAO;CAER,IAAI,KAAK,WAAW,GAAG;EACtB,QAAQ,aAAa;EACrB,OAAO;CACR;CAEA,MAAM,IAAI,YAAY,IAAI,CAAC;CAC3B,MAAM,QAAQ,YAA2B;EACxC,MAAM,IAAI,gBACT;GAAE,YAAY;GAAY,QAAQ,CAAC;IAAE,MAAM;IAAqB;GAAQ,CAAC;EAAE,GAC3E,IAAI,CACL;CACD;CAKA,MAAM,aAAa;EAAE,IAHpB,aAAa,QAAQ,QAAQ,OAAO,YAAY,SAAS,WACrD,YAAY,OACb,KAAA,MACqC,CAAC;EAAI,GAAG;CAAa;CAG9D,MAAM,oBAAoB;EAAE,GAAI,eAAe,CAAC;EAAI,GAAG;CAAK,EAAE,gBAAgB;CAC9E,IAAI,CAAC,mBACJ,KAAK,EAAE,KAAK,8BAA8B,CAAC;CAE5C,MAAM,KAAM,aAAa,MAAM,MAAM;CACrC,MAAM,OAAO;EACZ,IAAI,MAAM;EACV,OACC,OAAO,MAAM,UAAU,WAAW,KAAK,QAAS,aAAa;EAC9D,aAAa;EACb,MAAM;EACN,QAAQ,MAAM,UAAU,aAAa;CACtC;CACA,IAAI;CACJ,IAAI;EAEH,UAAU,MAAM,4BAA4B;GAC3C,SAAS,IAAI;GACb,KAAK,MAAM,OAAO,MAAM,KAAA;GACxB;EACD,CAAC;CACF,QAAQ;EACP,OAAO,KAAK,EAAE,KAAK,sBAAsB,CAAC;CAC3C;CACA,MAAM,UAAU,IAAI,IAAI,QAAQ,KAAK,WAAW,OAAO,KAAK,CAAC;CAC7D,IAAI,CAAC,KAAK,OAAO,UAAU,QAAQ,IAAI,KAAK,CAAC,GAC5C,KAAK,EAAE,KAAK,6BAA6B,CAAC;CAE3C,QAAQ,8BAAa,IAAI,KAAK,GAAE,YAAY;CAC5C,OAAO;AACR"}

package/dist/poll/outcomeFields.d.ts

@@ -0,0 +1,38 @@
+import { Field } from "payload";
+
+//#region src/poll/outcomeFields.d.ts
+/** The default poll-outcome fields, keyed by field. What the `poll.outcomeFields` seam receives. */
+type DefaultOutcomeFields = {
+  winningValues: Field;
+  resolvedAt: Field;
+};
+/**
+ * Composes the forms poll `outcome` group. Receives the two default fields; the returned array
+ * becomes the group's fields verbatim, so swapping `winningValues` for a host component (e.g. a
+ * relationship picker over the voteable records), reordering, or adding a field is explicit.
+ * `pollOutcomeBeforeChange` validates every stored winning value against the poll's effective
+ * options server-side regardless of which component renders it, so a swap cannot bypass the
+ * membership check.
+ */
+type OutcomeFieldsOverride = (args: {
+  defaultFields: DefaultOutcomeFields;
+}) => Field[];
+/**
+ * The winners field (`poll.outcome.winningValues`): a `hasMany` text field whose default admin
+ * component is the `poll-options` endpoint select rendered as a multi-select, so a tie records
+ * every winner. Each stored value is matched against the poll's effective options by
+ * `pollOutcomeBeforeChange`; a host may swap the component, but the stored contract stays an array
+ * of `PollOption.value` strings so membership validation keeps working.
+ */
+declare const buildWinningValuesField: () => Field;
+/**
+ * The resolved-at stamp field (`poll.outcome.resolvedAt`): read-only and locked against every
+ * caller write via field-level access, so only `pollOutcomeBeforeChange` (which runs after access
+ * filtering) can stamp it. Kept in the defaults so a host override that preserves it keeps the lock.
+ */
+declare const buildResolvedAtField: () => Field;
+/** Both defaults, exactly what the `poll.outcomeFields` seam is handed. */
+declare const buildDefaultOutcomeFields: () => DefaultOutcomeFields;
+//#endregion
+export { DefaultOutcomeFields, OutcomeFieldsOverride, buildDefaultOutcomeFields, buildResolvedAtField, buildWinningValuesField };
+//# sourceMappingURL=outcomeFields.d.ts.map

package/dist/poll/outcomeFields.js

@@ -0,0 +1,52 @@
+import { keys } from "../translations/keys.js";
+import { labelForKey } from "../translations/server.js";
+//#region src/poll/outcomeFields.ts
+const ENDPOINT_OPTIONS_SELECT_REF = "@10x-media/form-builder/client#EndpointOptionsSelect";
+/**
+* The winners field (`poll.outcome.winningValues`): a `hasMany` text field whose default admin
+* component is the `poll-options` endpoint select rendered as a multi-select, so a tie records
+* every winner. Each stored value is matched against the poll's effective options by
+* `pollOutcomeBeforeChange`; a host may swap the component, but the stored contract stays an array
+* of `PollOption.value` strings so membership validation keeps working.
+*/
+const buildWinningValuesField = () => ({
+	name: "winningValues",
+	type: "text",
+	hasMany: true,
+	label: labelForKey(keys.pollWinningValue),
+	admin: {
+		condition: (data) => data?.poll?.type === "manual",
+		components: { Field: {
+			path: ENDPOINT_OPTIONS_SELECT_REF,
+			clientProps: {
+				endpoint: "poll-options",
+				descriptionKey: keys.pollWinningValueDescription,
+				isMulti: true
+			}
+		} }
+	}
+});
+/**
+* The resolved-at stamp field (`poll.outcome.resolvedAt`): read-only and locked against every
+* caller write via field-level access, so only `pollOutcomeBeforeChange` (which runs after access
+* filtering) can stamp it. Kept in the defaults so a host override that preserves it keeps the lock.
+*/
+const buildResolvedAtField = () => ({
+	name: "resolvedAt",
+	type: "date",
+	label: labelForKey(keys.pollResolvedAt),
+	admin: { readOnly: true },
+	access: {
+		create: () => false,
+		update: () => false
+	}
+});
+/** Both defaults, exactly what the `poll.outcomeFields` seam is handed. */
+const buildDefaultOutcomeFields = () => ({
+	winningValues: buildWinningValuesField(),
+	resolvedAt: buildResolvedAtField()
+});
+//#endregion
+export { buildDefaultOutcomeFields, buildResolvedAtField, buildWinningValuesField };
+
+//# sourceMappingURL=outcomeFields.js.map

package/dist/poll/outcomeFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcomeFields.js","names":[],"sources":["../../src/poll/outcomeFields.ts"],"sourcesContent":["import type { Field } from 'payload'\nimport { keys } from '../translations/keys'\nimport { labelForKey } from '../translations/server'\n\nconst ENDPOINT_OPTIONS_SELECT_REF = '@10x-media/form-builder/client#EndpointOptionsSelect'\n\n/** The default poll-outcome fields, keyed by field. What the `poll.outcomeFields` seam receives. */\nexport type DefaultOutcomeFields = {\n\twinningValues: Field\n\tresolvedAt: Field\n}\n\n/**\n * Composes the forms poll `outcome` group. Receives the two default fields; the returned array\n * becomes the group's fields verbatim, so swapping `winningValues` for a host component (e.g. a\n * relationship picker over the voteable records), reordering, or adding a field is explicit.\n * `pollOutcomeBeforeChange` validates every stored winning value against the poll's effective\n * options server-side regardless of which component renders it, so a swap cannot bypass the\n * membership check.\n */\nexport type OutcomeFieldsOverride = (args: { defaultFields: DefaultOutcomeFields }) => Field[]\n\n/**\n * The winners field (`poll.outcome.winningValues`): a `hasMany` text field whose default admin\n * component is the `poll-options` endpoint select rendered as a multi-select, so a tie records\n * every winner. Each stored value is matched against the poll's effective options by\n * `pollOutcomeBeforeChange`; a host may swap the component, but the stored contract stays an array\n * of `PollOption.value` strings so membership validation keeps working.\n */\nexport const buildWinningValuesField = (): Field => ({\n\tname: 'winningValues',\n\ttype: 'text',\n\thasMany: true,\n\tlabel: labelForKey(keys.pollWinningValue),\n\tadmin: {\n\t\t// Only a `manual` poll has a winner to hand-pick; `mostVoted` and `source` auto-resolve on close,\n\t\t// so a hand-picked value would just be discarded. Show the field for `manual` alone. A stored value\n\t\t// survives a save because Payload keeps a condition-hidden field's value in form state and resubmits\n\t\t// it, and the outcome hook's early-return leaves winningValues untouched when a save omits it. The\n\t\t// first Condition arg is the whole document (the field sits at poll.outcome.winningValues), so read\n\t\t// poll.type off it.\n\t\tcondition: (data) => (data as { poll?: { type?: string } })?.poll?.type === 'manual',\n\t\tcomponents: {\n\t\t\tField: {\n\t\t\t\tpath: ENDPOINT_OPTIONS_SELECT_REF,\n\t\t\t\tclientProps: {\n\t\t\t\t\tendpoint: 'poll-options',\n\t\t\t\t\tdescriptionKey: keys.pollWinningValueDescription,\n\t\t\t\t\tisMulti: true,\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t},\n})\n\n/**\n * The resolved-at stamp field (`poll.outcome.resolvedAt`): read-only and locked against every\n * caller write via field-level access, so only `pollOutcomeBeforeChange` (which runs after access\n * filtering) can stamp it. Kept in the defaults so a host override that preserves it keeps the lock.\n */\nexport const buildResolvedAtField = (): Field => ({\n\tname: 'resolvedAt',\n\ttype: 'date',\n\tlabel: labelForKey(keys.pollResolvedAt),\n\tadmin: { readOnly: true },\n\taccess: { create: () => false, update: () => false },\n})\n\n/** Both defaults, exactly what the `poll.outcomeFields` seam is handed. */\nexport const buildDefaultOutcomeFields = (): DefaultOutcomeFields => ({\n\twinningValues: buildWinningValuesField(),\n\tresolvedAt: buildResolvedAtField(),\n})\n"],"mappings":";;;AAIA,MAAM,8BAA8B;;;;;;;;AAyBpC,MAAa,iCAAwC;CACpD,MAAM;CACN,MAAM;CACN,SAAS;CACT,OAAO,YAAY,KAAK,gBAAgB;CACxC,OAAO;EAON,YAAY,SAAU,MAAuC,MAAM,SAAS;EAC5E,YAAY,EACX,OAAO;GACN,MAAM;GACN,aAAa;IACZ,UAAU;IACV,gBAAgB,KAAK;IACrB,SAAS;GACV;EACD,EACD;CACD;AACD;;;;;;AAOA,MAAa,8BAAqC;CACjD,MAAM;CACN,MAAM;CACN,OAAO,YAAY,KAAK,cAAc;CACtC,OAAO,EAAE,UAAU,KAAK;CACxB,QAAQ;EAAE,cAAc;EAAO,cAAc;CAAM;AACpD;;AAGA,MAAa,mCAAyD;CACrE,eAAe,wBAAwB;CACvC,YAAY,qBAAqB;AAClC"}

package/dist/poll/pollTypeRegistry.d.ts

@@ -0,0 +1,34 @@
+import { PollOutcomeStrategy } from "./definePollType.js";
+import { Payload } from "payload";
+
+//#region src/poll/pollTypeRegistry.d.ts
+type PollTypeRegistry = Map<string, PollOutcomeStrategy>;
+/**
+ * Host-supplied outcome strategies: a keyed record (the key forces `type`, like the field-type
+ * registry) or a plain array. There are no boolean toggles because the three built-ins are always
+ * registered; a host entry with a built-in's `type` replaces it.
+ */
+type PollTypesConfig = Record<string, PollOutcomeStrategy> | PollOutcomeStrategy[];
+/** The default: an admin records `winningValues` by hand, so there is nothing to auto-resolve. */
+declare const manualStrategy: PollOutcomeStrategy;
+/**
+ * Delegate to the poll's configured option source `resolveOutcome` (the same domain resolver that
+ * feeds explicit `resolvePollOutcome` auto mode before this task shipped). Returns `undefined` when
+ * the poll has no source, the source is unregistered, or it does not implement `resolveOutcome`, so a
+ * misconfigured poll never throws from the close job or the read fallback; a source that resolves to
+ * no decision (its `resolveOutcome` returns `undefined`) also yields `undefined`.
+ */
+declare const sourceStrategy: PollOutcomeStrategy;
+/**
+ * The active poll-type registry: the three always-registered built-ins (`manual`, `mostVoted`,
+ * `source`) plus any host strategies from the plugin `poll.types` option. A host entry keyed by (or
+ * carrying a `type` of) a built-in slug replaces that built-in. Mirrors the field-type registry: a
+ * record key forces the strategy's `type` so a keyed override cannot rename the slot.
+ */
+declare const resolvePollTypes: (config?: PollTypesConfig) => PollTypeRegistry;
+/** Store the resolved registry on the config so `resolvePollOutcome` can reach it via `payload.config`. */
+declare const stashPollTypes: (custom: Record<string, unknown> | undefined, registry: PollTypeRegistry) => Record<string, unknown>;
+declare const pollTypesOf: (payload: Payload) => PollTypeRegistry;
+//#endregion
+export { PollTypeRegistry, PollTypesConfig, manualStrategy, pollTypesOf, resolvePollTypes, sourceStrategy, stashPollTypes };
+//# sourceMappingURL=pollTypeRegistry.d.ts.map

package/dist/poll/pollTypeRegistry.js

@@ -0,0 +1,69 @@
+import { keys } from "../translations/keys.js";
+import { applyRegistryConfig } from "../plugin/applyRegistryConfig.js";
+import { customStateOf, stashCustomState } from "../plugin/customState.js";
+import { pollOptionSourcesOf } from "./resolvePollOptions.js";
+import { definePollType } from "./definePollType.js";
+import { mostVotedStrategy } from "./mostVoted.js";
+//#region src/poll/pollTypeRegistry.ts
+/** The default: an admin records `winningValues` by hand, so there is nothing to auto-resolve. */
+const manualStrategy = definePollType({
+	type: "manual",
+	label: keys.pollTypeManual,
+	resolveOutcome: () => void 0
+});
+/** One winner set as a deduped array of non-empty strings, or `undefined` when the source yields none. */
+const normalizeSourceOutcome = (value) => {
+	if (value === void 0) return;
+	const cleaned = [...new Set((Array.isArray(value) ? value : [value]).filter((entry) => typeof entry === "string" && entry.length > 0))];
+	return cleaned.length > 0 ? cleaned : void 0;
+};
+/**
+* Delegate to the poll's configured option source `resolveOutcome` (the same domain resolver that
+* feeds explicit `resolvePollOutcome` auto mode before this task shipped). Returns `undefined` when
+* the poll has no source, the source is unregistered, or it does not implement `resolveOutcome`, so a
+* misconfigured poll never throws from the close job or the read fallback; a source that resolves to
+* no decision (its `resolveOutcome` returns `undefined`) also yields `undefined`.
+*/
+const sourceStrategy = definePollType({
+	type: "source",
+	label: keys.pollTypeSource,
+	resolveOutcome: async ({ payload, req, form, poll }) => {
+		const optionSource = typeof poll.optionSource === "string" && poll.optionSource.length > 0 ? poll.optionSource : void 0;
+		if (!optionSource) return;
+		const source = pollOptionSourcesOf(payload).get(optionSource);
+		if (!source?.resolveOutcome) return;
+		const config = poll.sourceConfig != null && typeof poll.sourceConfig === "object" ? poll.sourceConfig : {};
+		return normalizeSourceOutcome(await source.resolveOutcome({
+			config,
+			form: {
+				id: form.id,
+				title: typeof form.title === "string" ? form.title : void 0
+			},
+			payload,
+			req
+		}));
+	}
+});
+/**
+* The active poll-type registry: the three always-registered built-ins (`manual`, `mostVoted`,
+* `source`) plus any host strategies from the plugin `poll.types` option. A host entry keyed by (or
+* carrying a `type` of) a built-in slug replaces that built-in. Mirrors the field-type registry: a
+* record key forces the strategy's `type` so a keyed override cannot rename the slot.
+*/
+const resolvePollTypes = (config) => {
+	const registry = new Map([
+		[manualStrategy.type, manualStrategy],
+		[mostVotedStrategy.type, mostVotedStrategy],
+		[sourceStrategy.type, sourceStrategy]
+	]);
+	if (Array.isArray(config)) for (const strategy of config) registry.set(strategy.type, strategy);
+	else if (config) applyRegistryConfig(registry, config);
+	return registry;
+};
+/** Store the resolved registry on the config so `resolvePollOutcome` can reach it via `payload.config`. */
+const stashPollTypes = (custom, registry) => stashCustomState(custom, { pollTypes: registry });
+const pollTypesOf = (payload) => customStateOf(payload).pollTypes ?? /* @__PURE__ */ new Map();
+//#endregion
+export { manualStrategy, pollTypesOf, resolvePollTypes, sourceStrategy, stashPollTypes };
+
+//# sourceMappingURL=pollTypeRegistry.js.map

package/dist/poll/pollTypeRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollTypeRegistry.js","names":[],"sources":["../../src/poll/pollTypeRegistry.ts"],"sourcesContent":["import type { Payload } from 'payload'\nimport { applyRegistryConfig } from '../plugin/applyRegistryConfig'\nimport { customStateOf, stashCustomState } from '../plugin/customState'\nimport { keys } from '../translations/keys'\nimport { definePollType, type PollOutcomeStrategy } from './definePollType'\nimport { mostVotedStrategy } from './mostVoted'\nimport { pollOptionSourcesOf } from './resolvePollOptions'\n\nexport type PollTypeRegistry = Map<string, PollOutcomeStrategy>\n\n/**\n * Host-supplied outcome strategies: a keyed record (the key forces `type`, like the field-type\n * registry) or a plain array. There are no boolean toggles because the three built-ins are always\n * registered; a host entry with a built-in's `type` replaces it.\n */\nexport type PollTypesConfig = Record<string, PollOutcomeStrategy> | PollOutcomeStrategy[]\n\n/** The default: an admin records `winningValues` by hand, so there is nothing to auto-resolve. */\nexport const manualStrategy: PollOutcomeStrategy = definePollType({\n\ttype: 'manual',\n\tlabel: keys.pollTypeManual,\n\tresolveOutcome: () => undefined,\n})\n\n/** One winner set as a deduped array of non-empty strings, or `undefined` when the source yields none. */\nconst normalizeSourceOutcome = (value: string | string[] | undefined): string[] | undefined => {\n\tif (value === undefined) {\n\t\treturn undefined\n\t}\n\tconst cleaned = [\n\t\t...new Set(\n\t\t\t(Array.isArray(value) ? value : [value]).filter(\n\t\t\t\t(entry): entry is string => typeof entry === 'string' && entry.length > 0\n\t\t\t)\n\t\t),\n\t]\n\treturn cleaned.length > 0 ? cleaned : undefined\n}\n\n/**\n * Delegate to the poll's configured option source `resolveOutcome` (the same domain resolver that\n * feeds explicit `resolvePollOutcome` auto mode before this task shipped). Returns `undefined` when\n * the poll has no source, the source is unregistered, or it does not implement `resolveOutcome`, so a\n * misconfigured poll never throws from the close job or the read fallback; a source that resolves to\n * no decision (its `resolveOutcome` returns `undefined`) also yields `undefined`.\n */\nexport const sourceStrategy: PollOutcomeStrategy = definePollType({\n\ttype: 'source',\n\tlabel: keys.pollTypeSource,\n\tresolveOutcome: async ({ payload, req, form, poll }) => {\n\t\tconst optionSource =\n\t\t\ttypeof poll.optionSource === 'string' && poll.optionSource.length > 0\n\t\t\t\t? poll.optionSource\n\t\t\t\t: undefined\n\t\tif (!optionSource) {\n\t\t\treturn undefined\n\t\t}\n\t\tconst source = pollOptionSourcesOf(payload).get(optionSource)\n\t\tif (!source?.resolveOutcome) {\n\t\t\treturn undefined\n\t\t}\n\t\tconst config =\n\t\t\tpoll.sourceConfig != null && typeof poll.sourceConfig === 'object'\n\t\t\t\t? (poll.sourceConfig as Record<string, unknown>)\n\t\t\t\t: {}\n\t\treturn normalizeSourceOutcome(\n\t\t\tawait source.resolveOutcome({\n\t\t\t\tconfig,\n\t\t\t\tform: { id: form.id, title: typeof form.title === 'string' ? form.title : undefined },\n\t\t\t\tpayload,\n\t\t\t\treq,\n\t\t\t})\n\t\t)\n\t},\n})\n\n/**\n * The active poll-type registry: the three always-registered built-ins (`manual`, `mostVoted`,\n * `source`) plus any host strategies from the plugin `poll.types` option. A host entry keyed by (or\n * carrying a `type` of) a built-in slug replaces that built-in. Mirrors the field-type registry: a\n * record key forces the strategy's `type` so a keyed override cannot rename the slot.\n */\nexport const resolvePollTypes = (config?: PollTypesConfig): PollTypeRegistry => {\n\tconst registry: PollTypeRegistry = new Map([\n\t\t[manualStrategy.type, manualStrategy],\n\t\t[mostVotedStrategy.type, mostVotedStrategy],\n\t\t[sourceStrategy.type, sourceStrategy],\n\t])\n\tif (Array.isArray(config)) {\n\t\tfor (const strategy of config) {\n\t\t\tregistry.set(strategy.type, strategy)\n\t\t}\n\t} else if (config) {\n\t\t// A keyed record shares the sibling registries' merge (the key forces `type`). There are no\n\t\t// boolean toggles here because the three built-ins are always registered, so those branches\n\t\t// are inert for this always-strategy config.\n\t\tapplyRegistryConfig(registry, config)\n\t}\n\treturn registry\n}\n\ntype PollTypesCustomState = { pollTypes: PollTypeRegistry }\n\n/** Store the resolved registry on the config so `resolvePollOutcome` can reach it via `payload.config`. */\nexport const stashPollTypes = (\n\tcustom: Record<string, unknown> | undefined,\n\tregistry: PollTypeRegistry\n): Record<string, unknown> =>\n\tstashCustomState<PollTypesCustomState>(custom, { pollTypes: registry })\n\nexport const pollTypesOf = (payload: Payload): PollTypeRegistry =>\n\tcustomStateOf<PollTypesCustomState>(payload).pollTypes ?? new Map()\n"],"mappings":";;;;;;;;AAkBA,MAAa,iBAAsC,eAAe;CACjE,MAAM;CACN,OAAO,KAAK;CACZ,sBAAsB,KAAA;AACvB,CAAC;;AAGD,MAAM,0BAA0B,UAA+D;CAC9F,IAAI,UAAU,KAAA,GACb;CAED,MAAM,UAAU,CACf,GAAG,IAAI,KACL,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK,GAAG,QACvC,UAA2B,OAAO,UAAU,YAAY,MAAM,SAAS,CACzE,CACD,CACD;CACA,OAAO,QAAQ,SAAS,IAAI,UAAU,KAAA;AACvC;;;;;;;;AASA,MAAa,iBAAsC,eAAe;CACjE,MAAM;CACN,OAAO,KAAK;CACZ,gBAAgB,OAAO,EAAE,SAAS,KAAK,MAAM,WAAW;EACvD,MAAM,eACL,OAAO,KAAK,iBAAiB,YAAY,KAAK,aAAa,SAAS,IACjE,KAAK,eACL,KAAA;EACJ,IAAI,CAAC,cACJ;EAED,MAAM,SAAS,oBAAoB,OAAO,EAAE,IAAI,YAAY;EAC5D,IAAI,CAAC,QAAQ,gBACZ;EAED,MAAM,SACL,KAAK,gBAAgB,QAAQ,OAAO,KAAK,iBAAiB,WACtD,KAAK,eACN,CAAC;EACL,OAAO,uBACN,MAAM,OAAO,eAAe;GAC3B;GACA,MAAM;IAAE,IAAI,KAAK;IAAI,OAAO,OAAO,KAAK,UAAU,WAAW,KAAK,QAAQ,KAAA;GAAU;GACpF;GACA;EACD,CAAC,CACF;CACD;AACD,CAAC;;;;;;;AAQD,MAAa,oBAAoB,WAA+C;CAC/E,MAAM,WAA6B,IAAI,IAAI;EAC1C,CAAC,eAAe,MAAM,cAAc;EACpC,CAAC,kBAAkB,MAAM,iBAAiB;EAC1C,CAAC,eAAe,MAAM,cAAc;CACrC,CAAC;CACD,IAAI,MAAM,QAAQ,MAAM,GACvB,KAAK,MAAM,YAAY,QACtB,SAAS,IAAI,SAAS,MAAM,QAAQ;MAE/B,IAAI,QAIV,oBAAoB,UAAU,MAAM;CAErC,OAAO;AACR;;AAKA,MAAa,kBACZ,QACA,aAEA,iBAAuC,QAAQ,EAAE,WAAW,SAAS,CAAC;AAEvE,MAAa,eAAe,YAC3B,cAAoC,OAAO,EAAE,6BAAa,IAAI,IAAI"}

package/dist/poll/registry.d.ts

@@ -0,0 +1,17 @@
+import { AnyPollOptionSource } from "./definePollOptionSource.js";
+import { RegistryConfig } from "../plugin/applyRegistryConfig.js";
+
+//#region src/poll/registry.d.ts
+type PollOptionSourceRegistry = Map<string, AnyPollOptionSource>;
+/** `false` removes a source, `true` keeps it (no-op: there are no built-ins), a definition adds or replaces one. */
+type PollOptionSourceOption = boolean | AnyPollOptionSource;
+type PollOptionSourcesConfig = RegistryConfig<AnyPollOptionSource>;
+/**
+ * Resolve the active poll option-source registry from a consumer map. Unlike the consent and
+ * action registries there are no built-in defaults: the registry starts empty and only host
+ * definitions populate it, so `true`/`false` entries are accepted but change nothing.
+ */
+declare const resolvePollOptionSources: (config?: PollOptionSourcesConfig) => PollOptionSourceRegistry;
+//#endregion
+export { PollOptionSourceOption, PollOptionSourceRegistry, PollOptionSourcesConfig, resolvePollOptionSources };
+//# sourceMappingURL=registry.d.ts.map

package/dist/poll/registry.js

@@ -0,0 +1,12 @@
+import { applyRegistryConfig } from "../plugin/applyRegistryConfig.js";
+//#region src/poll/registry.ts
+/**
+* Resolve the active poll option-source registry from a consumer map. Unlike the consent and
+* action registries there are no built-in defaults: the registry starts empty and only host
+* definitions populate it, so `true`/`false` entries are accepted but change nothing.
+*/
+const resolvePollOptionSources = (config = {}) => applyRegistryConfig(/* @__PURE__ */ new Map(), config);
+//#endregion
+export { resolvePollOptionSources };
+
+//# sourceMappingURL=registry.js.map

package/dist/poll/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../src/poll/registry.ts"],"sourcesContent":["import { applyRegistryConfig, type RegistryConfig } from '../plugin/applyRegistryConfig'\nimport type { AnyPollOptionSource } from './definePollOptionSource'\n\nexport type PollOptionSourceRegistry = Map<string, AnyPollOptionSource>\n\n/** `false` removes a source, `true` keeps it (no-op: there are no built-ins), a definition adds or replaces one. */\nexport type PollOptionSourceOption = boolean | AnyPollOptionSource\n\nexport type PollOptionSourcesConfig = RegistryConfig<AnyPollOptionSource>\n\n/**\n * Resolve the active poll option-source registry from a consumer map. Unlike the consent and\n * action registries there are no built-in defaults: the registry starts empty and only host\n * definitions populate it, so `true`/`false` entries are accepted but change nothing.\n */\nexport const resolvePollOptionSources = (\n\tconfig: PollOptionSourcesConfig = {}\n): PollOptionSourceRegistry => applyRegistryConfig(new Map<string, AnyPollOptionSource>(), config)\n"],"mappings":";;;;;;;AAeA,MAAa,4BACZ,SAAkC,CAAC,MACL,oCAAoB,IAAI,IAAiC,GAAG,MAAM"}

package/dist/poll/resolvePollCloseRequest.js

@@ -0,0 +1,106 @@
+import { keys } from "../translations/keys.js";
+import { asTranslate } from "../translations/server.js";
+import { isPollClosed, pollConfigOf } from "../form/pollState.js";
+import { resolvePollOutcome } from "./resolvePollOutcome.js";
+import { FORMS_SLUG } from "../collections/forms.js";
+//#region src/poll/resolvePollCloseRequest.ts
+/** The recorded winning set as non-empty strings; empty means no winner has been set yet. */
+const winnersOf = (poll) => {
+	const winners = poll.outcome?.winningValues;
+	if (!Array.isArray(winners)) return [];
+	return winners.filter((value) => typeof value === "string" && value.length > 0);
+};
+/** The selected outcome strategy slug; an absent or empty `type` is `manual`. */
+const strategyOf = (poll) => typeof poll.type === "string" && poll.type.length > 0 ? poll.type : "manual";
+/**
+* Decide what closing a poll now should do, purely from a loaded form so the branch logic is testable
+* without a boot. `manual` requires a winner to already be recorded (closing only stamps the time);
+* `mostVoted`, `source`, and any host strategy auto-resolve on close. Refuses a non-poll form and an
+* already-closed poll (idempotency), so the request helper performs no write unless this returns `ok`.
+*/
+const planPollClose = (form) => {
+	const poll = pollConfigOf(form.poll);
+	if (form.pollEnabled !== true || !poll) return {
+		ok: false,
+		reason: "not-poll"
+	};
+	if (isPollClosed(poll)) return {
+		ok: false,
+		reason: "already-closed"
+	};
+	if (strategyOf(poll) === "manual" && winnersOf(poll).length === 0) return {
+		ok: false,
+		reason: "manual-no-winner"
+	};
+	return {
+		ok: true,
+		resolveOutcome: strategyOf(poll) !== "manual"
+	};
+};
+/**
+* Authorize and perform a manual poll close backing `POST /:id/close`. Only an authenticated caller
+* may close (anonymous is always 403, mirroring the other resolve* helpers); the route is a trusted
+* admin action, so the load and write run with `overrideAccess`. Sets `closesAt` to now through
+* `payload.update` so the collection hooks run, then for a non-manual strategy resolves the winners via
+* `resolvePollOutcome` (auto mode; a non-decidable poll simply records none and the read fallback heals
+* it later). A `manual` poll with no winner recorded is refused (400) so closing never strands a poll
+* with no result. Idempotent: an already-closed poll returns 400 rather than re-closing.
+*/
+const resolvePollCloseRequest = async (args) => {
+	const { payload, formId, isAuthed, pollVotesEnabled, req } = args;
+	if (!isAuthed) return {
+		status: 403,
+		body: { errors: [{ message: "Forbidden" }] }
+	};
+	if (formId == null) return {
+		status: 400,
+		body: { errors: [{ message: "Missing form id" }] }
+	};
+	const form = await payload.findByID({
+		collection: FORMS_SLUG,
+		id: formId,
+		depth: 0,
+		overrideAccess: true,
+		req
+	}).catch(() => null);
+	if (!form) return {
+		status: 404,
+		body: { errors: [{ message: "Not found" }] }
+	};
+	const plan = planPollClose(form);
+	if (!plan.ok) {
+		if (plan.reason === "manual-no-winner") return {
+			status: 400,
+			body: { errors: [{ message: asTranslate(req.t)(keys.pollCloseManualNoWinner) }] }
+		};
+		return {
+			status: 400,
+			body: { errors: [{ message: plan.reason === "already-closed" ? "Poll already closed" : "Not a poll" }] }
+		};
+	}
+	const closesAt = (/* @__PURE__ */ new Date()).toISOString();
+	await payload.update({
+		collection: FORMS_SLUG,
+		id: formId,
+		data: { poll: { closesAt } },
+		depth: 0,
+		overrideAccess: true,
+		req
+	});
+	return {
+		status: 200,
+		body: {
+			closesAt,
+			winningValues: plan.resolveOutcome ? await resolvePollOutcome({
+				payload,
+				formId,
+				pollVotesEnabled,
+				req
+			}) : winnersOf(pollConfigOf(form.poll) ?? {})
+		}
+	};
+};
+//#endregion
+export { resolvePollCloseRequest };
+
+//# sourceMappingURL=resolvePollCloseRequest.js.map

package/dist/poll/resolvePollCloseRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePollCloseRequest.js","names":[],"sources":["../../src/poll/resolvePollCloseRequest.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from 'payload'\nimport { FORMS_SLUG } from '../collections/forms'\nimport { isPollClosed, type PollConfigLike, pollConfigOf } from '../form/pollState'\nimport { keys } from '../translations/keys'\nimport { asTranslate } from '../translations/server'\nimport { resolvePollOutcome } from './resolvePollOutcome'\n\n/** The recorded winning set as non-empty strings; empty means no winner has been set yet. */\nconst winnersOf = (poll: PollConfigLike): string[] => {\n\tconst winners = poll.outcome?.winningValues\n\tif (!Array.isArray(winners)) {\n\t\treturn []\n\t}\n\treturn winners.filter((value): value is string => typeof value === 'string' && value.length > 0)\n}\n\n/** The selected outcome strategy slug; an absent or empty `type` is `manual`. */\nconst strategyOf = (poll: PollConfigLike): string =>\n\ttypeof poll.type === 'string' && poll.type.length > 0 ? poll.type : 'manual'\n\n/** The slice of a loaded form the close planner reads. */\nexport type PollCloseFormLike = { pollEnabled?: boolean | null; poll?: unknown }\n\nexport type PollClosePlan =\n\t| { ok: false; reason: 'already-closed' | 'manual-no-winner' | 'not-poll' }\n\t| { ok: true; resolveOutcome: boolean }\n\n/**\n * Decide what closing a poll now should do, purely from a loaded form so the branch logic is testable\n * without a boot. `manual` requires a winner to already be recorded (closing only stamps the time);\n * `mostVoted`, `source`, and any host strategy auto-resolve on close. Refuses a non-poll form and an\n * already-closed poll (idempotency), so the request helper performs no write unless this returns `ok`.\n */\nexport const planPollClose = (form: PollCloseFormLike): PollClosePlan => {\n\tconst poll = pollConfigOf(form.poll)\n\tif (form.pollEnabled !== true || !poll) {\n\t\treturn { ok: false, reason: 'not-poll' }\n\t}\n\tif (isPollClosed(poll)) {\n\t\treturn { ok: false, reason: 'already-closed' }\n\t}\n\tif (strategyOf(poll) === 'manual' && winnersOf(poll).length === 0) {\n\t\treturn { ok: false, reason: 'manual-no-winner' }\n\t}\n\treturn { ok: true, resolveOutcome: strategyOf(poll) !== 'manual' }\n}\n\nexport type ResolvePollCloseRequestArgs = {\n\tpayload: Payload\n\tformId: number | string | undefined\n\t/** Whether the caller is authenticated (an admin/user). */\n\tisAuthed: boolean\n\t/** Whether the hidden tally store backs the outcome aggregation (see `resolvePollOutcome`). */\n\tpollVotesEnabled?: boolean\n\treq: PayloadRequest\n}\n\nexport type ResolvePollCloseRequestResult = {\n\tstatus: number\n\tbody: { closesAt: string; winningValues: string[] } | { errors: { message: string }[] }\n}\n\n/**\n * Authorize and perform a manual poll close backing `POST /:id/close`. Only an authenticated caller\n * may close (anonymous is always 403, mirroring the other resolve* helpers); the route is a trusted\n * admin action, so the load and write run with `overrideAccess`. Sets `closesAt` to now through\n * `payload.update` so the collection hooks run, then for a non-manual strategy resolves the winners via\n * `resolvePollOutcome` (auto mode; a non-decidable poll simply records none and the read fallback heals\n * it later). A `manual` poll with no winner recorded is refused (400) so closing never strands a poll\n * with no result. Idempotent: an already-closed poll returns 400 rather than re-closing.\n */\nexport const resolvePollCloseRequest = async (\n\targs: ResolvePollCloseRequestArgs\n): Promise<ResolvePollCloseRequestResult> => {\n\tconst { payload, formId, isAuthed, pollVotesEnabled, req } = args\n\tif (!isAuthed) {\n\t\treturn { status: 403, body: { errors: [{ message: 'Forbidden' }] } }\n\t}\n\tif (formId == null) {\n\t\treturn { status: 400, body: { errors: [{ message: 'Missing form id' }] } }\n\t}\n\tconst form = await payload\n\t\t.findByID({ collection: FORMS_SLUG, id: formId, depth: 0, overrideAccess: true, req })\n\t\t.catch(() => null)\n\tif (!form) {\n\t\treturn { status: 404, body: { errors: [{ message: 'Not found' }] } }\n\t}\n\n\tconst plan = planPollClose(form as PollCloseFormLike)\n\tif (!plan.ok) {\n\t\tif (plan.reason === 'manual-no-winner') {\n\t\t\treturn {\n\t\t\t\tstatus: 400,\n\t\t\t\tbody: { errors: [{ message: asTranslate(req.t)(keys.pollCloseManualNoWinner) }] },\n\t\t\t}\n\t\t}\n\t\tconst message = plan.reason === 'already-closed' ? 'Poll already closed' : 'Not a poll'\n\t\treturn { status: 400, body: { errors: [{ message }] } }\n\t}\n\n\tconst closesAt = new Date().toISOString()\n\tawait payload.update({\n\t\tcollection: FORMS_SLUG,\n\t\tid: formId,\n\t\tdata: { poll: { closesAt } },\n\t\tdepth: 0,\n\t\toverrideAccess: true,\n\t\treq,\n\t})\n\n\tconst winningValues = plan.resolveOutcome\n\t\t? await resolvePollOutcome({ payload, formId, pollVotesEnabled, req })\n\t\t: winnersOf(pollConfigOf(form.poll) ?? {})\n\treturn { status: 200, body: { closesAt, winningValues } }\n}\n"],"mappings":";;;;;;;AAQA,MAAM,aAAa,SAAmC;CACrD,MAAM,UAAU,KAAK,SAAS;CAC9B,IAAI,CAAC,MAAM,QAAQ,OAAO,GACzB,OAAO,CAAC;CAET,OAAO,QAAQ,QAAQ,UAA2B,OAAO,UAAU,YAAY,MAAM,SAAS,CAAC;AAChG;;AAGA,MAAM,cAAc,SACnB,OAAO,KAAK,SAAS,YAAY,KAAK,KAAK,SAAS,IAAI,KAAK,OAAO;;;;;;;AAerE,MAAa,iBAAiB,SAA2C;CACxE,MAAM,OAAO,aAAa,KAAK,IAAI;CACnC,IAAI,KAAK,gBAAgB,QAAQ,CAAC,MACjC,OAAO;EAAE,IAAI;EAAO,QAAQ;CAAW;CAExC,IAAI,aAAa,IAAI,GACpB,OAAO;EAAE,IAAI;EAAO,QAAQ;CAAiB;CAE9C,IAAI,WAAW,IAAI,MAAM,YAAY,UAAU,IAAI,EAAE,WAAW,GAC/D,OAAO;EAAE,IAAI;EAAO,QAAQ;CAAmB;CAEhD,OAAO;EAAE,IAAI;EAAM,gBAAgB,WAAW,IAAI,MAAM;CAAS;AAClE;;;;;;;;;;AA0BA,MAAa,0BAA0B,OACtC,SAC4C;CAC5C,MAAM,EAAE,SAAS,QAAQ,UAAU,kBAAkB,QAAQ;CAC7D,IAAI,CAAC,UACJ,OAAO;EAAE,QAAQ;EAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,CAAC,EAAE;CAAE;CAEpE,IAAI,UAAU,MACb,OAAO;EAAE,QAAQ;EAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,kBAAkB,CAAC,EAAE;CAAE;CAE1E,MAAM,OAAO,MAAM,QACjB,SAAS;EAAE,YAAY;EAAY,IAAI;EAAQ,OAAO;EAAG,gBAAgB;EAAM;CAAI,CAAC,EACpF,YAAY,IAAI;CAClB,IAAI,CAAC,MACJ,OAAO;EAAE,QAAQ;EAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,CAAC,EAAE;CAAE;CAGpE,MAAM,OAAO,cAAc,IAAyB;CACpD,IAAI,CAAC,KAAK,IAAI;EACb,IAAI,KAAK,WAAW,oBACnB,OAAO;GACN,QAAQ;GACR,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,IAAI,CAAC,EAAE,KAAK,uBAAuB,EAAE,CAAC,EAAE;EACjF;EAGD,OAAO;GAAE,QAAQ;GAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SADzB,KAAK,WAAW,mBAAmB,wBAAwB,aAC1B,CAAC,EAAE;EAAE;CACvD;CAEA,MAAM,4BAAW,IAAI,KAAK,GAAE,YAAY;CACxC,MAAM,QAAQ,OAAO;EACpB,YAAY;EACZ,IAAI;EACJ,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE;EAC3B,OAAO;EACP,gBAAgB;EAChB;CACD,CAAC;CAKD,OAAO;EAAE,QAAQ;EAAK,MAAM;GAAE;GAAU,eAHlB,KAAK,iBACxB,MAAM,mBAAmB;IAAE;IAAS;IAAQ;IAAkB;GAAI,CAAC,IACnE,UAAU,aAAa,KAAK,IAAI,KAAK,CAAC,CAAC;EACY;CAAE;AACzD"}

package/dist/poll/resolvePollOptions.d.ts

@@ -0,0 +1,29 @@
+import { PollOption } from "./definePollOptionSource.js";
+import { PollOptionSourceRegistry } from "./registry.js";
+import { Payload, PayloadRequest } from "payload";
+
+//#region src/poll/resolvePollOptions.d.ts
+type ResolvePollOptionsArgs = {
+  payload: Payload;
+  req?: PayloadRequest; /** A loaded forms document; its top-level `pollEnabled` flag and `poll` config drive resolution. */
+  form: {
+    id: number | string;
+    title?: string | null;
+    pollEnabled?: boolean | null;
+    poll?: unknown;
+  }; /** Registry override for plugin-internal callers; defaults to the registry the plugin stashed on the config. */
+  sources?: PollOptionSourceRegistry;
+};
+/**
+ * Resolve a poll-enabled form's choice options from its configured option source (plugin option
+ * `poll.sources`). Returns `undefined` when the form is not poll-enabled or has no `optionSource`
+ * set, so hand-authored options render unchanged. Hosts call this server-side and hand the result
+ * to `toFormDocument(doc, { pollOptions })`; submission validation calls it too, making the
+ * resolved values the only accepted answers. Throws when the configured source type is not
+ * registered or its `resolve` fails; results are cached per request (keyed by form id) when a
+ * `req` is provided.
+ */
+declare const resolvePollOptions: (args: ResolvePollOptionsArgs) => Promise<PollOption[] | undefined>;
+//#endregion
+export { ResolvePollOptionsArgs, resolvePollOptions };
+//# sourceMappingURL=resolvePollOptions.d.ts.map

package/dist/poll/resolvePollOptions.js

@@ -0,0 +1,52 @@
+import { customStateOf, stashCustomState } from "../plugin/customState.js";
+import { pollConfigOf } from "../form/pollState.js";
+//#region src/poll/resolvePollOptions.ts
+/** Store the resolved registry on the config so `resolvePollOptions` can find it via `payload.config`. */
+const stashPollOptionSources = (custom, registry) => stashCustomState(custom, { pollOptionSources: registry });
+const pollOptionSourcesOf = (payload) => customStateOf(payload).pollOptionSources ?? /* @__PURE__ */ new Map();
+const CACHE_KEY = "formBuilderPollOptionsCache";
+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;
+};
+/**
+* Resolve a poll-enabled form's choice options from its configured option source (plugin option
+* `poll.sources`). Returns `undefined` when the form is not poll-enabled or has no `optionSource`
+* set, so hand-authored options render unchanged. Hosts call this server-side and hand the result
+* to `toFormDocument(doc, { pollOptions })`; submission validation calls it too, making the
+* resolved values the only accepted answers. Throws when the configured source type is not
+* registered or its `resolve` fails; results are cached per request (keyed by form id) when a
+* `req` is provided.
+*/
+const resolvePollOptions = async (args) => {
+	const { payload, req, form, sources } = args;
+	const poll = pollConfigOf(form.poll);
+	const optionSource = typeof poll?.optionSource === "string" ? poll.optionSource : void 0;
+	if (form.pollEnabled !== true || !poll || !optionSource) return;
+	const source = (sources ?? pollOptionSourcesOf(payload)).get(optionSource);
+	if (!source) throw new Error(`Poll option source "${optionSource}" is not registered. Register it via the plugin's poll.sources option.`);
+	const cache = cacheOf(req);
+	const cacheKey = String(form.id);
+	const cached = cache?.get(cacheKey);
+	if (cached) return cached;
+	const config = poll.sourceConfig != null && typeof poll.sourceConfig === "object" ? poll.sourceConfig : {};
+	const options = await source.resolve({
+		config,
+		form: {
+			id: form.id,
+			title: typeof form.title === "string" ? form.title : void 0
+		},
+		payload,
+		req
+	});
+	cache?.set(cacheKey, options);
+	return options;
+};
+//#endregion
+export { pollOptionSourcesOf, resolvePollOptions, stashPollOptionSources };
+
+//# sourceMappingURL=resolvePollOptions.js.map

package/dist/poll/resolvePollOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePollOptions.js","names":[],"sources":["../../src/poll/resolvePollOptions.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from 'payload'\nimport { pollConfigOf } from '../form/pollState'\nimport { customStateOf, stashCustomState } from '../plugin/customState'\nimport type { PollOption } from './definePollOptionSource'\nimport type { PollOptionSourceRegistry } from './registry'\n\ntype PollCustomState = { pollOptionSources: PollOptionSourceRegistry }\n\n/** Store the resolved registry on the config so `resolvePollOptions` can find it via `payload.config`. */\nexport const stashPollOptionSources = (\n\tcustom: Record<string, unknown> | undefined,\n\tregistry: PollOptionSourceRegistry\n): Record<string, unknown> =>\n\tstashCustomState<PollCustomState>(custom, { pollOptionSources: registry })\n\nexport const pollOptionSourcesOf = (payload: Payload): PollOptionSourceRegistry =>\n\tcustomStateOf<PollCustomState>(payload).pollOptionSources ?? new Map()\n\nconst CACHE_KEY = 'formBuilderPollOptionsCache'\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\nexport type ResolvePollOptionsArgs = {\n\tpayload: Payload\n\treq?: PayloadRequest\n\t/** A loaded forms document; its top-level `pollEnabled` flag and `poll` config drive resolution. */\n\tform: { id: number | string; title?: string | null; pollEnabled?: boolean | null; poll?: unknown }\n\t/** Registry override for plugin-internal callers; defaults to the registry the plugin stashed on the config. */\n\tsources?: PollOptionSourceRegistry\n}\n\n/**\n * Resolve a poll-enabled form's choice options from its configured option source (plugin option\n * `poll.sources`). Returns `undefined` when the form is not poll-enabled or has no `optionSource`\n * set, so hand-authored options render unchanged. Hosts call this server-side and hand the result\n * to `toFormDocument(doc, { pollOptions })`; submission validation calls it too, making the\n * resolved values the only accepted answers. Throws when the configured source type is not\n * registered or its `resolve` fails; results are cached per request (keyed by form id) when a\n * `req` is provided.\n */\nexport const resolvePollOptions = async (\n\targs: ResolvePollOptionsArgs\n): Promise<PollOption[] | undefined> => {\n\tconst { payload, req, form, sources } = args\n\tconst poll = pollConfigOf(form.poll)\n\tconst optionSource = typeof poll?.optionSource === 'string' ? poll.optionSource : undefined\n\tif (form.pollEnabled !== true || !poll || !optionSource) {\n\t\treturn undefined\n\t}\n\tconst source = (sources ?? pollOptionSourcesOf(payload)).get(optionSource)\n\tif (!source) {\n\t\tthrow new Error(\n\t\t\t`Poll option source \"${optionSource}\" is not registered. Register it via the plugin's poll.sources option.`\n\t\t)\n\t}\n\tconst cache = cacheOf(req)\n\tconst cacheKey = String(form.id)\n\tconst cached = cache?.get(cacheKey)\n\tif (cached) {\n\t\treturn cached\n\t}\n\tconst config =\n\t\tpoll.sourceConfig != null && typeof poll.sourceConfig === 'object'\n\t\t\t? (poll.sourceConfig as Record<string, unknown>)\n\t\t\t: {}\n\tconst options = await source.resolve({\n\t\tconfig,\n\t\tform: { id: form.id, title: typeof form.title === 'string' ? form.title : undefined },\n\t\tpayload,\n\t\treq,\n\t})\n\tcache?.set(cacheKey, options)\n\treturn options\n}\n"],"mappings":";;;;AASA,MAAa,0BACZ,QACA,aAEA,iBAAkC,QAAQ,EAAE,mBAAmB,SAAS,CAAC;AAE1E,MAAa,uBAAuB,YACnC,cAA+B,OAAO,EAAE,qCAAqB,IAAI,IAAI;AAEtE,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;;;;;;;;;;AAoBA,MAAa,qBAAqB,OACjC,SACuC;CACvC,MAAM,EAAE,SAAS,KAAK,MAAM,YAAY;CACxC,MAAM,OAAO,aAAa,KAAK,IAAI;CACnC,MAAM,eAAe,OAAO,MAAM,iBAAiB,WAAW,KAAK,eAAe,KAAA;CAClF,IAAI,KAAK,gBAAgB,QAAQ,CAAC,QAAQ,CAAC,cAC1C;CAED,MAAM,UAAU,WAAW,oBAAoB,OAAO,GAAG,IAAI,YAAY;CACzE,IAAI,CAAC,QACJ,MAAM,IAAI,MACT,uBAAuB,aAAa,uEACrC;CAED,MAAM,QAAQ,QAAQ,GAAG;CACzB,MAAM,WAAW,OAAO,KAAK,EAAE;CAC/B,MAAM,SAAS,OAAO,IAAI,QAAQ;CAClC,IAAI,QACH,OAAO;CAER,MAAM,SACL,KAAK,gBAAgB,QAAQ,OAAO,KAAK,iBAAiB,WACtD,KAAK,eACN,CAAC;CACL,MAAM,UAAU,MAAM,OAAO,QAAQ;EACpC;EACA,MAAM;GAAE,IAAI,KAAK;GAAI,OAAO,OAAO,KAAK,UAAU,WAAW,KAAK,QAAQ,KAAA;EAAU;EACpF;EACA;CACD,CAAC;CACD,OAAO,IAAI,UAAU,OAAO;CAC5B,OAAO;AACR"}

package/dist/poll/resolvePollOptionsRequest.js

@@ -0,0 +1,50 @@
+import { resolveEffectivePollOptions } from "./effectivePollOptions.js";
+import { FORMS_SLUG } from "../collections/forms.js";
+//#region src/poll/resolvePollOptionsRequest.ts
+/**
+* Authorize and resolve the `GET /:id/poll-options` request backing the admin winner select:
+* authenticated callers get the poll's effective options (source-resolved or authored, exactly the
+* set outcome validation accepts), anonymous callers are always refused. Statuses mirror the
+* results endpoint: 400 missing id, 403 unauthenticated, 404 unknown form, 503 when the option
+* source fails (fail closed).
+*/
+const resolvePollOptionsRequest = async (args) => {
+	const { payload, formId, isAuthed, req } = args;
+	if (!isAuthed) return {
+		status: 403,
+		body: { errors: [{ message: "Forbidden" }] }
+	};
+	if (formId == null) return {
+		status: 400,
+		body: { errors: [{ message: "Missing form id" }] }
+	};
+	const form = await payload.findByID({
+		collection: FORMS_SLUG,
+		id: formId,
+		depth: 0,
+		req
+	}).catch(() => null);
+	if (!form) return {
+		status: 404,
+		body: { errors: [{ message: "Not found" }] }
+	};
+	try {
+		return {
+			status: 200,
+			body: { options: await resolveEffectivePollOptions({
+				payload,
+				req,
+				form
+			}) }
+		};
+	} catch {
+		return {
+			status: 503,
+			body: { errors: [{ message: "Poll options unavailable" }] }
+		};
+	}
+};
+//#endregion
+export { resolvePollOptionsRequest };
+
+//# sourceMappingURL=resolvePollOptionsRequest.js.map

package/dist/poll/resolvePollOptionsRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePollOptionsRequest.js","names":[],"sources":["../../src/poll/resolvePollOptionsRequest.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from 'payload'\nimport { FORMS_SLUG } from '../collections/forms'\nimport type { PollOption } from './definePollOptionSource'\nimport { resolveEffectivePollOptions } from './effectivePollOptions'\n\nexport type ResolvePollOptionsRequestArgs = {\n\tpayload: Payload\n\tformId: number | string | undefined\n\t/** Whether the caller is authenticated (an admin/user). */\n\tisAuthed: boolean\n\treq?: PayloadRequest\n}\n\nexport type ResolvePollOptionsRequestResult = {\n\tstatus: number\n\tbody: { options: PollOption[] } | { errors: { message: string }[] }\n}\n\n/**\n * Authorize and resolve the `GET /:id/poll-options` request backing the admin winner select:\n * authenticated callers get the poll's effective options (source-resolved or authored, exactly the\n * set outcome validation accepts), anonymous callers are always refused. Statuses mirror the\n * results endpoint: 400 missing id, 403 unauthenticated, 404 unknown form, 503 when the option\n * source fails (fail closed).\n */\nexport const resolvePollOptionsRequest = async (\n\targs: ResolvePollOptionsRequestArgs\n): Promise<ResolvePollOptionsRequestResult> => {\n\tconst { payload, formId, isAuthed, req } = args\n\tif (!isAuthed) {\n\t\treturn { status: 403, body: { errors: [{ message: 'Forbidden' }] } }\n\t}\n\tif (formId == null) {\n\t\treturn { status: 400, body: { errors: [{ message: 'Missing form id' }] } }\n\t}\n\t// Load under the caller's own read access (no overrideAccess): a tenant-scoped `forms.access.read`\n\t// then refuses a cross-tenant form id (null -> 404), so an authed user cannot read another tenant's\n\t// poll options.\n\tconst form = await payload\n\t\t.findByID({ collection: FORMS_SLUG, id: formId, depth: 0, req })\n\t\t.catch(() => null)\n\tif (!form) {\n\t\treturn { status: 404, body: { errors: [{ message: 'Not found' }] } }\n\t}\n\ttry {\n\t\tconst options = await resolveEffectivePollOptions({ payload, req, form })\n\t\treturn { status: 200, body: { options } }\n\t} catch {\n\t\treturn { status: 503, body: { errors: [{ message: 'Poll options unavailable' }] } }\n\t}\n}\n"],"mappings":";;;;;;;;;;AAyBA,MAAa,4BAA4B,OACxC,SAC8C;CAC9C,MAAM,EAAE,SAAS,QAAQ,UAAU,QAAQ;CAC3C,IAAI,CAAC,UACJ,OAAO;EAAE,QAAQ;EAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,CAAC,EAAE;CAAE;CAEpE,IAAI,UAAU,MACb,OAAO;EAAE,QAAQ;EAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,kBAAkB,CAAC,EAAE;CAAE;CAK1E,MAAM,OAAO,MAAM,QACjB,SAAS;EAAE,YAAY;EAAY,IAAI;EAAQ,OAAO;EAAG;CAAI,CAAC,EAC9D,YAAY,IAAI;CAClB,IAAI,CAAC,MACJ,OAAO;EAAE,QAAQ;EAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,CAAC,EAAE;CAAE;CAEpE,IAAI;EAEH,OAAO;GAAE,QAAQ;GAAK,MAAM,EAAE,SAAA,MADR,4BAA4B;IAAE;IAAS;IAAK;GAAK,CAAC,EAClC;EAAE;CACzC,QAAQ;EACP,OAAO;GAAE,QAAQ;GAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,SAAS,2BAA2B,CAAC,EAAE;EAAE;CACnF;AACD"}

package/dist/poll/resolvePollOutcome.d.ts

@@ -0,0 +1,40 @@
+import { Payload, PayloadRequest } from "payload";
+
+//#region src/poll/resolvePollOutcome.d.ts
+type ResolvePollOutcomeArgs = {
+  payload: Payload;
+  formId: number | string;
+  /**
+   * The winning set: stable option values, each matching one of the poll's choice values (the
+   * host's contract with `PollOption.value`). Pass more than one for a tie, an empty array to clear
+   * the outcome. Omit to auto-resolve via the poll's selected outcome strategy (`poll.type`).
+   */
+  winningValues?: string[];
+  /**
+   * Whether the hidden tally store backs the auto-resolve aggregation (`mostVoted` and any host
+   * strategy that calls `aggregate()`). False keeps the submission scan, so persist-off forms
+   * only resolve correctly with the store enabled.
+   */
+  pollVotesEnabled?: boolean;
+  req?: PayloadRequest;
+};
+/**
+ * Record a poll's final outcome server-side, in one of two modes:
+ * - explicit: pass `winningValues` when host code already knows the winner(s); more than one is a
+ *   tie, and an empty array clears the outcome;
+ * - auto: omit it and the poll's selected outcome strategy (`poll.type`, from the `poll.types`
+ *   registry, defaulting to `manual`) resolves the winners. `manual` is a no-op; `mostVoted` reads
+ *   the aggregated results field; `source` delegates to the option source. A strategy that is not
+ *   yet decidable (or `manual`) writes nothing and this returns an empty set, so auto mode is safe
+ *   to call repeatedly from the close job and the read fallback.
+ *
+ * Every write runs through `payload.update` with `overrideAccess`, so the forms collection hook
+ * validates each value against the poll's effective options and owns the `poll.outcome.resolvedAt`
+ * stamp in both modes (auto-resolved winners are validated exactly as hand-picked ones). Throws only
+ * when the form does not exist or is not poll-enabled. Returns the recorded winning set (empty when
+ * auto mode did not decide).
+ */
+declare const resolvePollOutcome: (args: ResolvePollOutcomeArgs) => Promise<string[]>;
+//#endregion
+export { ResolvePollOutcomeArgs, resolvePollOutcome };
+//# sourceMappingURL=resolvePollOutcome.d.ts.map