udp-stencil-component-library 26.5.0-beta.2 → 26.5.0-beta.21

package/dist/collection/components/forms/udp-question-form/renderer/runtime/codecs.js

@@ -0,0 +1,456 @@
+import { FieldTypeId } from "../../core";
+import { getDriveFileId } from "./types";
+/** Display-only types — no user input, no codec needed. Decoded value is always null. */
+const noopCodec = {
+    decode: () => null,
+    encode: () => '',
+};
+const stringCodec = {
+    decode: wire => (wire == null || wire === '' ? null : wire),
+    encode: value => value !== null && value !== void 0 ? value : '',
+};
+const numberCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        const n = Number(wire);
+        return Number.isFinite(n) ? n : null;
+    },
+    encode: value => (value == null ? '' : String(value)),
+};
+const yesNoCodec = {
+    decode: wire => wire === 'true' || wire === 'false' || wire === 'na' ? wire : null,
+    encode: value => {
+        if (value == null)
+            return '';
+        if (typeof value === 'boolean')
+            return value ? 'true' : 'false';
+        return value === 'true' || value === 'false' || value === 'na' ? value : '';
+    },
+};
+/**
+ * Multi-select encoding observed in legacy submissions stores a single selection as the bare
+ * value string (e.g. `"one"`). The encoding for *multiple* selections is unverified — likely
+ * CSV. Decoder splits on `,` and trims; encoder joins with `,`. Revisit once we have a real
+ * multi-selection submission to confirm.
+ *
+ * TODO: verify against a real multi-selection submission.
+ */
+const multiSelectCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        return wire.split(',').map(s => s.trim()).filter(s => s.length > 0);
+    },
+    encode: value => (value == null || value.length === 0 ? '' : value.join(',')),
+};
+const locationCodec = {
+    decode: wire => {
+        var _a, _b, _c, _d;
+        if (wire == null || wire === '')
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(wire);
+        }
+        catch (_e) {
+            return null;
+        }
+        const freeform = (_a = parsed.address) !== null && _a !== void 0 ? _a : '';
+        const hasAddress = freeform.length > 0 ||
+            parsed.streetNumber != null ||
+            parsed.streetName != null ||
+            parsed.municipality != null ||
+            parsed.countrySubdivisionName != null ||
+            parsed.postalCode != null ||
+            parsed.country != null;
+        const address = hasAddress
+            ? {
+                freeformAddress: freeform,
+                streetNumber: parsed.streetNumber,
+                streetName: parsed.streetName,
+                municipality: parsed.municipality,
+                countrySubdivisionName: parsed.countrySubdivisionName,
+                postalCode: parsed.postalCode,
+                country: parsed.country,
+            }
+            : null;
+        return {
+            latitude: (_b = parsed.latitude) !== null && _b !== void 0 ? _b : null,
+            longitude: (_c = parsed.longitude) !== null && _c !== void 0 ? _c : null,
+            address,
+            timestamp: (_d = parsed.timestamp) !== null && _d !== void 0 ? _d : null,
+        };
+    },
+    encode: value => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (value == null)
+            return '';
+        if (value.latitude == null && value.longitude == null && !value.address)
+            return '';
+        const wire = {
+            latitude: (_a = value.latitude) !== null && _a !== void 0 ? _a : null,
+            longitude: (_b = value.longitude) !== null && _b !== void 0 ? _b : null,
+            address: (_d = (_c = value.address) === null || _c === void 0 ? void 0 : _c.freeformAddress) !== null && _d !== void 0 ? _d : null,
+            streetNumber: (_e = value.address) === null || _e === void 0 ? void 0 : _e.streetNumber,
+            streetName: (_f = value.address) === null || _f === void 0 ? void 0 : _f.streetName,
+            municipality: (_g = value.address) === null || _g === void 0 ? void 0 : _g.municipality,
+            countrySubdivisionName: (_h = value.address) === null || _h === void 0 ? void 0 : _h.countrySubdivisionName,
+            postalCode: (_j = value.address) === null || _j === void 0 ? void 0 : _j.postalCode,
+            country: (_k = value.address) === null || _k === void 0 ? void 0 : _k.country,
+            timestamp: (_l = value.timestamp) !== null && _l !== void 0 ? _l : null,
+        };
+        return JSON.stringify(wire);
+    },
+};
+/**
+ * File / image upload wire format (matches legacy renderer):
+ *   - Comma-joined list of tokens
+ *   - Each token is `<urlencoded-filename>|udp:<driveFileId>` for an already-
+ *     stored file, or a bare `<urlencoded-filename>` for a pending upload (the
+ *     server rewrites bare names to `|udp:<id>` form during the multipart
+ *     POST/PUT and persists the rewritten value).
+ *   - Legacy also produces `|b64:<data>` for inline-base64 fallbacks; pass-1
+ *     decodes those as stored items without bytes (the user has to re-upload
+ *     if they want to keep the file). Out of scope to round-trip b64 inline.
+ *
+ * The actual `File` bytes for a pending upload are stored on the
+ * `UdpFileItem.file` field and extracted from the form-engine values map by
+ * `extractFilesFromValues()` (called by the wire adapter) — they never travel
+ * through the codec's string-only encode/decode.
+ */
+const fileListCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        const tokens = wire.split(',').map(t => t.trim()).filter(t => t.length > 0);
+        if (tokens.length === 0)
+            return null;
+        const items = [];
+        for (const token of tokens) {
+            const item = parseFileToken(token);
+            if (item)
+                items.push(item);
+        }
+        return items.length > 0 ? items : null;
+    },
+    encode: value => {
+        if (value == null || value.length === 0)
+            return '';
+        return value
+            .map(item => {
+            if (item.kind === 'pending')
+                return encodeURIComponent(item.file.name);
+            return `${encodeURIComponent(item.name)}|udp:${item.driveFileId}`;
+        })
+            .join(',');
+    },
+};
+function parseFileToken(token) {
+    const pipeIdx = token.indexOf('|');
+    if (pipeIdx < 0) {
+        // Bare filename — shouldn't appear on load (server rewrites), but tolerate.
+        let name = token;
+        try {
+            name = decodeURIComponent(token);
+        }
+        catch (_a) {
+            /* fall through with raw token */
+        }
+        return { kind: 'stored', name, driveFileId: '' };
+    }
+    const encodedName = token.slice(0, pipeIdx);
+    const dataRef = token.slice(pipeIdx + 1);
+    let name = encodedName;
+    try {
+        name = decodeURIComponent(encodedName);
+    }
+    catch (_b) {
+        name = encodedName;
+    }
+    if (dataRef.startsWith('udp:')) {
+        return { kind: 'stored', name, driveFileId: dataRef.slice(4) };
+    }
+    if (dataRef.startsWith('b64:')) {
+        // Pass-1: surface as a stored placeholder with no driveFileId. Round-trip
+        // is best-effort; a re-save will drop the inline bytes.
+        return { kind: 'stored', name, driveFileId: '' };
+    }
+    return null;
+}
+/**
+ * Signature wire format: single file token (`<filename>|udp:<guid>` or bare
+ * `<filename>`). `fullName` + lat/lng/timestamp live in `metadata.signature`,
+ * not in the value string — they're merged onto the decoded value by
+ * `hydrateValueWithMetadata()`.
+ *
+ * Stored signatures decode to a placeholder `File` tagged with `driveFileId`
+ * (legacy convention). This keeps round-trip data inside the standard
+ * `SignatureValue` shape so it survives the component's `valueChanged` emits,
+ * which reconstruct the value via object spread of known keys only — a sidecar
+ * field on `SignatureValue` would be dropped the first time the user edited
+ * `fullName` without re-drawing.
+ */
+const signatureCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        const placeholder = buildSignaturePlaceholderFile(wire);
+        return {
+            file: placeholder,
+            fullName: null,
+            metadata: null,
+        };
+    },
+    encode: value => {
+        if (value == null)
+            return '';
+        if (!(value.file instanceof File))
+            return '';
+        const driveFileId = getDriveFileId(value.file);
+        if (driveFileId) {
+            // Untouched stored signature — round-trip the existing wire token.
+            return `${encodeURIComponent(value.file.name)}|udp:${driveFileId}`;
+        }
+        // Freshly-drawn (or replaced) signature — bare filename; server rewrites
+        // to `|udp:<id>` after upload via `FormFiles`.
+        return encodeURIComponent(value.file.name);
+    },
+};
+function buildSignaturePlaceholderFile(wire) {
+    const pipeIdx = wire.indexOf('|');
+    let encodedName = wire;
+    let driveFileId = '';
+    if (pipeIdx >= 0) {
+        encodedName = wire.slice(0, pipeIdx);
+        const dataRef = wire.slice(pipeIdx + 1);
+        if (dataRef.startsWith('udp:'))
+            driveFileId = dataRef.slice(4);
+    }
+    let name = encodedName;
+    try {
+        name = decodeURIComponent(encodedName);
+    }
+    catch (_a) {
+        name = encodedName;
+    }
+    const blob = new Blob([''], { type: 'image/png' });
+    const file = new File([blob], name, { type: 'image/png' });
+    if (driveFileId)
+        file.driveFileId = driveFileId;
+    return file;
+}
+const tableCodec = {
+    decode: wire => {
+        var _a;
+        if (wire == null || wire === '')
+            return { rows: [] };
+        let parsed;
+        try {
+            parsed = JSON.parse(wire);
+        }
+        catch (_b) {
+            return { rows: [] };
+        }
+        const raw = (_a = parsed === null || parsed === void 0 ? void 0 : parsed.rows) !== null && _a !== void 0 ? _a : parsed === null || parsed === void 0 ? void 0 : parsed.Rows;
+        if (!Array.isArray(raw))
+            return { rows: [] };
+        const rows = raw.filter((r) => r != null && typeof r === 'object' && !Array.isArray(r));
+        return { rows };
+    },
+    encode: value => {
+        if (!value || !Array.isArray(value.rows) || value.rows.length === 0)
+            return '';
+        return JSON.stringify({ rows: value.rows });
+    },
+};
+/**
+ * Pass-1 codec map. Only types we render in pass 1 + the display-only types that round-trip
+ * empty values.
+ */
+const codecsByFieldType = {
+    // Hidden — not rendered, but legacy submissions carry real values here
+    // (URL-seeded context, API-written data). String passthrough keeps the
+    // stored value flowing decode → form values → encode so a re-save never
+    // wipes it, and `?udpf_seed_…` params can seed hidden fields (legacy parity).
+    [FieldTypeId.Hidden]: stringCodec,
+    // Display-only types — round-trip null/empty. (Paragraph's wire value is
+    // written from `fieldProperties.paragraphText` by the serializer so legacy
+    // renderers, which display the stored VALUE, keep showing the prose.)
+    [FieldTypeId.Paragraph]: noopCodec,
+    [FieldTypeId.Tally]: noopCodec,
+    [FieldTypeId.FormMetadataDisplay]: noopCodec,
+    // Text input
+    [FieldTypeId.SingleLineText]: stringCodec,
+    [FieldTypeId.MultiLineText]: stringCodec,
+    // Single-value choice
+    [FieldTypeId.RadioButton]: stringCodec,
+    [FieldTypeId.DropdownSingleSelect]: stringCodec,
+    // Tri-state yes/no ('true' | 'false' | 'na') — legacy radio semantics.
+    [FieldTypeId.YesNo]: yesNoCodec,
+    // Multi-value choice — CSV of selected option values (legacy
+    // `selectable-list` joined selections with ','). Checkbox is the legacy
+    // multi-select checkbox list, NOT a single boolean.
+    [FieldTypeId.Checkbox]: multiSelectCodec,
+    [FieldTypeId.DropdownMultipleSelect]: multiSelectCodec,
+    [FieldTypeId.ListMultiSelect]: multiSelectCodec,
+    // Number
+    [FieldTypeId.Number]: numberCodec,
+    // Date / time — wire format from submissions:
+    //   DateSelector:     "YYYY-MM-DD"
+    //   TimeSelector:     "HH:mm"           (no seconds, despite field-properties min/max using HH:mm:ss)
+    //   DateTimeSelector: "YYYY-MM-DDTHH:mm" (T separator, no seconds)
+    // Pass-through for now; field renderers parse to Date/etc. as needed.
+    [FieldTypeId.DateSelector]: stringCodec,
+    [FieldTypeId.TimeSelector]: stringCodec,
+    [FieldTypeId.DateTimeSelector]: stringCodec,
+    // Location — JSON-stringified object (see locationCodec docs above).
+    [FieldTypeId.Location]: locationCodec,
+    // File / image upload — comma-joined `<filename>|udp:<guid>` tokens.
+    // Pending File bytes are extracted from the form-engine values by the wire
+    // adapter; the codec only handles the string-side of the wire shape.
+    [FieldTypeId.FileUpload]: fileListCodec,
+    [FieldTypeId.ImageUpload]: fileListCodec,
+    // Signature — single file token + `metadata.signature` sidecar.
+    [FieldTypeId.Signature]: signatureCodec,
+    // Table — JSON-stringified `{ rows: TableRow[] }`, keyed by column id.
+    [FieldTypeId.Table]: tableCodec,
+};
+/** Decode a wire value using the codec for `fieldTypeId`. Falls back to null for unmapped types. */
+export function decodeValue(fieldTypeId, wire) {
+    const codec = codecsByFieldType[fieldTypeId];
+    if (!codec)
+        return null;
+    return codec.decode(wire);
+}
+/** Encode a decoded value using the codec for `fieldTypeId`. Falls back to '' for unmapped types. */
+export function encodeValue(fieldTypeId, value) {
+    const codec = codecsByFieldType[fieldTypeId];
+    if (!codec)
+        return '';
+    return codec.encode(value);
+}
+/** Whether a field type is rendered in pass 1. Useful for the field-dispatch fallback. */
+export function isPassOneFieldType(fieldTypeId) {
+    return codecsByFieldType[fieldTypeId] !== undefined;
+}
+/**
+ * Merge metadata-sidecar fields onto the decoded value for types where the
+ * "value" string alone isn't the full user-visible state. Today only
+ * `Signature` needs this — `metadata.signature` carries `fullName` and the
+ * lat/lng/timestamp captured at stroke-end. Returns the value untouched for
+ * every other type.
+ */
+export function hydrateValueWithMetadata(fieldTypeId, decoded, metadata) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (fieldTypeId !== FieldTypeId.Signature)
+        return decoded;
+    const sig = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.signature) !== null && _a !== void 0 ? _a : null;
+    const baseValue = (decoded !== null && decoded !== void 0 ? decoded : null);
+    if (!sig && !baseValue)
+        return null;
+    const next = {
+        file: (_b = baseValue === null || baseValue === void 0 ? void 0 : baseValue.file) !== null && _b !== void 0 ? _b : null,
+        fullName: (_d = (_c = sig === null || sig === void 0 ? void 0 : sig.fullName) !== null && _c !== void 0 ? _c : baseValue === null || baseValue === void 0 ? void 0 : baseValue.fullName) !== null && _d !== void 0 ? _d : null,
+        metadata: sig != null
+            ? {
+                timestamp: (_e = sig.timestamp) !== null && _e !== void 0 ? _e : null,
+                latitude: (_f = sig.latitude) !== null && _f !== void 0 ? _f : null,
+                longitude: (_g = sig.longitude) !== null && _g !== void 0 ? _g : null,
+            }
+            : (_h = baseValue === null || baseValue === void 0 ? void 0 : baseValue.metadata) !== null && _h !== void 0 ? _h : null,
+    };
+    return next;
+}
+/**
+ * Walk a per-question-instance iterator and the values map to collect every
+ * `File` that needs to be uploaded with this submission. The wire adapter
+ * appends these under the `FormFiles` multipart field. The backend then
+ * matches them up with the bare-filename tokens in the JSON `Data` payload
+ * and rewrites those tokens to `<filename>|udp:<guid>` after persisting to
+ * UDP Drive.
+ *
+ * Iterating `(fieldTypeId, value)` pairs (instead of walking a `LoadedForm`
+ * directly) keeps this codec-layer helper free of the runtime expansion
+ * concern — the caller picks: walk the schema for a non-repeatable form,
+ * or walk `DynamicSection[]` so file uploads on copies 2+ of a repeatable
+ * section get collected too.
+ */
+export function extractFilesFromValueEntries(entries) {
+    const files = [];
+    for (const { fieldTypeId, value } of entries) {
+        switch (fieldTypeId) {
+            case FieldTypeId.FileUpload:
+            case FieldTypeId.ImageUpload: {
+                if (!Array.isArray(value))
+                    break;
+                for (const item of value) {
+                    if ((item === null || item === void 0 ? void 0 : item.kind) === 'pending' && item.file instanceof File) {
+                        files.push(item.file);
+                    }
+                }
+                break;
+            }
+            case FieldTypeId.Signature: {
+                const sv = value;
+                // Stored signatures carry a placeholder File tagged with driveFileId
+                // — don't re-upload it. Only push when this is a freshly-drawn (or
+                // replaced) signature.
+                if ((sv === null || sv === void 0 ? void 0 : sv.file) instanceof File && getDriveFileId(sv.file) == null) {
+                    files.push(sv.file);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return files;
+}
+/**
+ * Schema-aware convenience wrapper used by the submit flow. Walks the
+ * schema, reads each question's value out of the flat values map by the
+ * bare `question.id`, and delegates to `extractFilesFromValueEntries`.
+ *
+ * For non-repeatable forms this is the right walk. For repeatable forms
+ * the caller should iterate `DynamicSection[]` itself and pass the
+ * `(fieldTypeId, value)` pairs into `extractFilesFromValueEntries` — see
+ * `submit.ts`.
+ */
+export function extractFilesFromValues(loadedForm, values) {
+    const entries = [];
+    for (const section of loadedForm.sections) {
+        for (const question of section.questions) {
+            entries.push({ fieldTypeId: question.fieldTypeId, value: values[question.id] });
+        }
+    }
+    return extractFilesFromValueEntries(entries);
+}
+/**
+ * Produce the metadata blob to write into the envelope for a given question.
+ * For `Signature`, derives `metadata.signature` from the decoded value
+ * (fullName + lat/lng/timestamp); for every other type, passes through the
+ * existing metadata untouched. Returns `undefined` when nothing should be
+ * written.
+ */
+export function buildResponseMetadata(fieldTypeId, decodedValue, existingMetadata) {
+    var _a, _b, _c, _d, _e;
+    if (fieldTypeId !== FieldTypeId.Signature)
+        return existingMetadata;
+    const sv = decodedValue;
+    const hasFile = (sv === null || sv === void 0 ? void 0 : sv.file) instanceof File;
+    const fullName = (_a = sv === null || sv === void 0 ? void 0 : sv.fullName) !== null && _a !== void 0 ? _a : null;
+    const meta = (_b = sv === null || sv === void 0 ? void 0 : sv.metadata) !== null && _b !== void 0 ? _b : null;
+    const hasAny = hasFile || (fullName != null && fullName !== '') || meta != null;
+    if (!hasAny)
+        return existingMetadata;
+    const base = existingMetadata != null && typeof existingMetadata === 'object'
+        ? existingMetadata
+        : {};
+    return Object.assign(Object.assign({}, base), { signature: {
+            latitude: (_c = meta === null || meta === void 0 ? void 0 : meta.latitude) !== null && _c !== void 0 ? _c : null,
+            longitude: (_d = meta === null || meta === void 0 ? void 0 : meta.longitude) !== null && _d !== void 0 ? _d : null,
+            timestamp: (_e = meta === null || meta === void 0 ? void 0 : meta.timestamp) !== null && _e !== void 0 ? _e : null,
+            fullName,
+        } });
+}

package/dist/collection/components/forms/udp-question-form/renderer/runtime/comments-api.js

@@ -0,0 +1,36 @@
+import { ConfigService } from "../../../../../udp-utilities/api-config";
+import { makeApiCall } from "../../../../../udp-utilities/api/makeApiCall/makeApiCall";
+function commentsBaseUrl(ctx) {
+    return `${ConfigService.productV1ApiUrl}/UdpFormSubmission/${ctx.submissionId}/comments`;
+}
+function appendTenantIfPublic(url, ctx) {
+    if (!ctx.isPublicMode || !ctx.tenantId)
+        return url;
+    // Use URLSearchParams so we don't have to hand-roll `?` vs `&` or escape the
+    // tenantId — robust if the base URL ever gains its own query string.
+    const [base, existingQuery = ''] = url.split('?', 2);
+    const params = new URLSearchParams(existingQuery);
+    params.set('tenantId', String(ctx.tenantId));
+    return `${base}?${params.toString()}`;
+}
+/** POST a new comment. Client supplies its own `commentId` so we can render optimistically. */
+export async function postComment(ctx, body) {
+    const url = appendTenantIfPublic(`${commentsBaseUrl(ctx)}/${ctx.isPublicMode ? 'public' : 'private'}`, ctx);
+    await makeApiCall('POST', url, body, true);
+}
+/** PUT an existing comment. Public mode is not supported (matches legacy). */
+export async function putComment(ctx, commentId, body) {
+    if (ctx.isPublicMode) {
+        throw new Error('Comment updates are not supported in public mode.');
+    }
+    const url = `${commentsBaseUrl(ctx)}/${commentId}`;
+    await makeApiCall('PUT', url, body, true);
+}
+/** DELETE a comment (soft delete on the server). Public mode is not supported. */
+export async function deleteComment(ctx, commentId) {
+    if (ctx.isPublicMode) {
+        throw new Error('Comment deletion is not supported in public mode.');
+    }
+    const url = `${commentsBaseUrl(ctx)}/${commentId}`;
+    await makeApiCall('DELETE', url, null, true);
+}

package/dist/collection/components/forms/udp-question-form/renderer/runtime/comments-state.js

@@ -0,0 +1,184 @@
+import { v4 as uuidv4 } from "uuid";
+import { expandLoadedForm, } from "./dynamic-sections";
+/**
+ * Build the initial comments state from a loaded submission.
+ *
+ * Auto-expands `loadedForm` into dynamic sections and delegates to
+ * `buildInitialCommentsStateFromDynamicSections`. Suitable for the harness
+ * and the host's initial load; callers that own a DynamicSection[] across
+ * Add/Delete should use the dynamic-aware variant so per-copy comments
+ * survive state transitions.
+ */
+export function buildInitialCommentsState(loadedForm, submission) {
+    return buildInitialCommentsStateFromDynamicSections(expandLoadedForm({ loadedForm, submission }), submission);
+}
+/**
+ * Build the initial comments state from pre-expanded dynamic sections so
+ * each section instance gets its own bucket. Hydrates saved comments from
+ * the submission's response under the instance's slot name; hydrates legacy
+ * `draftComments` (preserved on `wireResponseData`) as the active draft so
+ * users coming from the legacy renderer keep their in-flight comments per
+ * copy.
+ */
+export function buildInitialCommentsStateFromDynamicSections(dynamicSections, submission) {
+    var _a, _b, _c, _d, _e, _f;
+    const byQuestionId = {};
+    const draftByQuestionId = {};
+    const editingCommentIdByQuestionId = {};
+    const wireRaw = (_a = submission === null || submission === void 0 ? void 0 : submission.wireResponseData) !== null && _a !== void 0 ? _a : {};
+    const responses = (_c = (_b = submission === null || submission === void 0 ? void 0 : submission.data) === null || _b === void 0 ? void 0 : _b.responses) !== null && _c !== void 0 ? _c : {};
+    for (const section of dynamicSections) {
+        const decodedSection = responses[section.slotName];
+        const rawSection = wireRaw[section.slotName];
+        for (const dynamicQuestion of section.questions) {
+            const key = dynamicQuestion.fieldKey;
+            const questionName = dynamicQuestion.schemaQuestion.name;
+            byQuestionId[key] = ((_e = (_d = decodedSection === null || decodedSection === void 0 ? void 0 : decodedSection[questionName]) === null || _d === void 0 ? void 0 : _d.comments) !== null && _e !== void 0 ? _e : []).map(c => (Object.assign({}, c)));
+            // Legacy `draftComments` lives on the raw wire shape only; parse.ts
+            // doesn't decode it. Pick the first non-empty entry as the active draft.
+            const rawQuestion = rawSection === null || rawSection === void 0 ? void 0 : rawSection[questionName];
+            const rawDrafts = rawQuestion && Array.isArray(rawQuestion.draftComments)
+                ? rawQuestion.draftComments
+                : [];
+            const firstDraft = rawDrafts.find(d => d && typeof d.value === 'string');
+            draftByQuestionId[key] = (_f = firstDraft === null || firstDraft === void 0 ? void 0 : firstDraft.value) !== null && _f !== void 0 ? _f : null;
+            editingCommentIdByQuestionId[key] = null;
+        }
+    }
+    return { byQuestionId, draftByQuestionId, editingCommentIdByQuestionId };
+}
+/** Visible comments — filters out soft-deleted entries. Use for UI lists and rail counts. */
+export function visibleComments(comments) {
+    return (comments !== null && comments !== void 0 ? comments : []).filter(c => c.isDeleted !== true);
+}
+/** Construct a new comment locally (matches what the legacy renderer would have built). */
+export function buildLocalComment(value, user, commentId) {
+    var _a, _b;
+    const now = new Date().toISOString();
+    return {
+        commentId: (commentId !== null && commentId !== void 0 ? commentId : uuidv4()),
+        userDisplayName: (_a = user.displayName) !== null && _a !== void 0 ? _a : null,
+        userId: ((_b = user.id) !== null && _b !== void 0 ? _b : null),
+        timestamp: now,
+        editedTimestamp: now,
+        isDeleted: false,
+        value: value !== null && value !== void 0 ? value : '',
+    };
+}
+/**
+ * Pure state transitions. Each returns a new top-level state object.
+ *
+ * All `key` parameters are Final Form field keys — equals the bare
+ * `question.id` for the original copy of any section and
+ * `${question.id}__${instanceId}` for copies 2+ of a repeatable section.
+ * The parameter is typed `string` (not `Guid`) because the suffixed form
+ * is no longer a bare GUID.
+ */
+export function setDraft(state, key, value, editingCommentId = null) {
+    return Object.assign(Object.assign({}, state), { draftByQuestionId: Object.assign(Object.assign({}, state.draftByQuestionId), { [key]: value }), editingCommentIdByQuestionId: Object.assign(Object.assign({}, state.editingCommentIdByQuestionId), { [key]: value == null ? null : editingCommentId }) });
+}
+export function appendComment(state, key, comment) {
+    var _a;
+    const prev = (_a = state.byQuestionId[key]) !== null && _a !== void 0 ? _a : [];
+    return Object.assign(Object.assign({}, state), { byQuestionId: Object.assign(Object.assign({}, state.byQuestionId), { [key]: [...prev, comment] }), draftByQuestionId: Object.assign(Object.assign({}, state.draftByQuestionId), { [key]: null }), editingCommentIdByQuestionId: Object.assign(Object.assign({}, state.editingCommentIdByQuestionId), { [key]: null }) });
+}
+export function replaceComment(state, key, commentId, patch) {
+    var _a;
+    const prev = (_a = state.byQuestionId[key]) !== null && _a !== void 0 ? _a : [];
+    const next = prev.map(c => (c.commentId === commentId ? Object.assign(Object.assign({}, c), patch) : c));
+    return Object.assign(Object.assign({}, state), { byQuestionId: Object.assign(Object.assign({}, state.byQuestionId), { [key]: next }) });
+}
+export function softDeleteComment(state, key, commentId) {
+    return replaceComment(state, key, commentId, {
+        isDeleted: true,
+        value: '',
+        editedTimestamp: new Date().toISOString(),
+    });
+}
+/**
+ * Drop ALL comment state (saved, draft, editing) for a list of field keys.
+ * Used by the host when a section instance is deleted so the dangling
+ * comments for that copy don't ride along on the next envelope.
+ */
+export function pruneKeys(state, keysToRemove) {
+    if (keysToRemove.length === 0)
+        return state;
+    const drop = new Set(keysToRemove);
+    const filter = (src) => {
+        const out = {};
+        for (const k of Object.keys(src)) {
+            if (!drop.has(k))
+                out[k] = src[k];
+        }
+        return out;
+    };
+    return {
+        byQuestionId: filter(state.byQuestionId),
+        draftByQuestionId: filter(state.draftByQuestionId),
+        editingCommentIdByQuestionId: filter(state.editingCommentIdByQuestionId),
+    };
+}
+/** Returns the commentId of the comment being edited in this question instance's draft, if any. */
+export function getEditingCommentId(state, key) {
+    var _a;
+    return (_a = state.editingCommentIdByQuestionId[key]) !== null && _a !== void 0 ? _a : null;
+}
+/**
+ * Resolve `(slotSection, questionName)` for a given Final Form `fieldKey`.
+ * Comment API bodies are slot-keyed (legacy contract), so we need this lookup
+ * at the edges. The slot section name is the dynamic instance's `slotName`
+ * (e.g. `section1` for the original, `section1_2` for the second copy).
+ *
+ * Two overloads keep the legacy callers working: pass `LoadedForm` for
+ * non-repeatable forms (the resolver auto-expands, so the fieldKey must be
+ * a bare question.id matching the original copy); pass `DynamicSection[]`
+ * to resolve into copies 2+.
+ */
+export function resolveSlotKeys(loadedFormOrSections, fieldKey) {
+    const sections = Array.isArray(loadedFormOrSections)
+        ? loadedFormOrSections
+        : expandLoadedForm({ loadedForm: loadedFormOrSections, submission: null });
+    for (const section of sections) {
+        for (const dynamicQuestion of section.questions) {
+            if (dynamicQuestion.fieldKey === fieldKey) {
+                return {
+                    sectionKey: section.slotName,
+                    questionKey: dynamicQuestion.schemaQuestion.name,
+                    question: dynamicQuestion.schemaQuestion,
+                };
+            }
+        }
+    }
+    return null;
+}
+/** True when this question's `fieldProperties.allowComments` is on. */
+export function isCommentsEnabledForQuestion(question) {
+    const fp = question.fieldProperties;
+    return (fp === null || fp === void 0 ? void 0 : fp.allowComments) === true;
+}
+/**
+ * Pre-filtered list of `(section, question)` pairs where comments are enabled,
+ * preserving section + question order. Cached by `LoadedForm` reference via a
+ * WeakMap so the rail and host-level gates don't re-walk the whole schema on
+ * every render. When the host swaps in a new form, the previous one becomes
+ * GC-eligible and the cache entry is collected with it.
+ */
+const commentsEnabledCache = new WeakMap();
+export function getCommentsEnabledQuestions(loadedForm) {
+    const hit = commentsEnabledCache.get(loadedForm);
+    if (hit)
+        return hit;
+    const fresh = [];
+    for (const section of loadedForm.sections) {
+        for (const question of section.questions) {
+            if (isCommentsEnabledForQuestion(question))
+                fresh.push({ section, question });
+        }
+    }
+    commentsEnabledCache.set(loadedForm, fresh);
+    return fresh;
+}
+/** True when any question in the form has `allowComments` set. Used to gate the rail entirely. */
+export function isCommentsEnabledForForm(loadedForm) {
+    return getCommentsEnabledQuestions(loadedForm).length > 0;
+}