udp-stencil-component-library 25.18.2-beta.1 → 25.18.2-beta.10

package/dist/collection/components/forms/udp-forms/udp-forms-renderer/udp-forms-renderer.js

@@ -1,31 +1,30 @@
 import { h } from "@stencil/core";
 import { throttle } from "lodash";
-import { UdpFormsFieldTypeEnum } from "../utils/enums";
 import { getCurrentTenantId } from "../../../../udp-utilities/tenant/tenantUtils";
 import { fetchLatestForms } from "../udp-forms-list/udp-form-api-utils";
-import { UdpFormsTypeEnum, UdpFormsPageIdEnum } from "../utils/enums";
-import { buildEmptyInitialValues } from "../utils/utils";
-import { FormSubmissionHandlerFactory } from "../utils/form-submission-handler/FormSubmissionHandlerFactory";
-import { UdpFormHandler } from "../utils/form-handler/UdpFormHandler";
-import { UdpFormSubmission } from "../utils/classes/UdpFormSubmission";
-import { UdpForm } from "../utils/classes/UdpForm";
-import { v4 as uuidv4 } from "uuid";
+import { UdpFormsTypeEnum, UdpFormsPageIdEnum, UdpFormsSubmissionStatusEnum } from "../udp-forms-utils/enums";
+import { buildEmptyCurrentValues } from "../udp-forms-utils/utils";
+import { FormSubmissionHandlerFactory } from "../udp-forms-utils/form-submission-handler/FormSubmissionHandlerFactory";
+import { UdpFormHandler } from "../udp-forms-utils/form-handler/UdpFormHandler";
+import { UdpFormSubmission } from "../udp-forms-utils/classes/UdpFormSubmission";
+import { UdpForm } from "../udp-forms-utils/classes/UdpForm";
+import { applyUrlSeedValuesForAll, initializeDynamicSections, initializeDynamicSectionsWithUrlContext, replaceUrlWithSubmissionId, enqueueSnackbarSuccess, enqueueSnackbarError } from "./udp-forms-renderer-utils/utils";
+import { computeDeleteRepeatableSection, computeDuplicateRepeatableSection } from "./udp-forms-renderer-utils/repeated-section-utils";
+import { applyQuestionCommentCrud } from "./udp-forms-renderer-utils/comments-crud-utils";
 export class UdpFormsRenderer {
     constructor() {
         this.isPublic = false;
         this.autoSaveDelay = 2000; // Debounce delay for auto-save in milliseconds (currently disabled)
-        this.initialValues = {};
+        this.urlContext = {}; // additional context from URL if needed, eg. generic1, gernic2, generic3, or any initial prepopulated values for form inputs. eg section1.question1 = 'some value'
+        this.currentValues = {}; // values of the current form state
         this.submitSuccessful = false;
-        this.currentFormData = {};
         this.isLoading = false;
         this.isSaving = false;
         this.isSubmitted = false;
-        this.saveErrorMessage = null;
         this.dynamicSections = [];
         this.isUpdatingSections = false;
         this.reRenderKey = 0;
-        this.isFormDirty = false;
-        this.isUserUpdatedSections = false;
+        this.hasUnsavedChanges = false;
         this.sideSheetFollowUpFormsList = []; // used for follow up forms. 
         this.followUpSideSheetTotalItems = 0; // used for follow up forms. 
         this.isFollowUpFormsSideSheetOpen = false; // used for follow up forms.
@@ -45,9 +44,19 @@ export class UdpFormsRenderer {
         };
         this.followUpParentSectionKey = ''; // used for follow up forms.
         this.followUpParentQuestionKey = ''; // used for follow up forms.
+        // Feature flags for public mode. Keep capabilities in the handlers,
+        // but disable UX / automatic flows for now.
+        this.publicFeatures = {
+            allowDraftSave: false, // public cannot save and return later
+            allowComments: true, // public can add comments locally; persistence handled by backend rules
+            allowFollowUpForms: false, // public does not support follow-up forms
+        };
         this.handleLaunchFollowUpFormSideSheet = async (e) => {
             try {
-                await this.performBackgroundSaveAndUpdateLocalSubmissionState(this.udpFormSubmission.data.submissionResponseData);
+                // Public forms do not support follow-up forms.
+                if (this.isPublic) {
+                    return;
+                }
                 this.followUpParentSectionKey = e.detail.sectionKey;
                 this.followUpParentQuestionKey = e.detail.questionKey;
                 await this.loadFollowUpForms(this.followUpParentSectionKey, this.followUpParentQuestionKey);
@@ -66,75 +75,20 @@ export class UdpFormsRenderer {
             this.isUpdatingSections = true;
             this.isLoading = true;
             try {
-                const sectionToClone = this.dynamicSections[index];
-                if (!sectionToClone)
-                    return;
-                const cloningSectionName = sectionToClone.name;
-                // Find existing repeat group indices
-                const repeatKeys = this.findRepeatGroupKeys(cloningSectionName, this.initialValues);
-                const nextRepeatIndex = repeatKeys.length > 0 ? Math.max(...repeatKeys) + 1 : 2;
-                const clonedSection = Object.assign(Object.assign({}, structuredClone(sectionToClone)), { formQuestions: sectionToClone.formQuestions.map(q => {
-                        const newQuestionObj = structuredClone(q);
-                        newQuestionObj.questionIdentifierKey = `${cloningSectionName}_${nextRepeatIndex}.${q.name}`;
-                        return newQuestionObj;
-                    }), isOriginalSection: false, sectionPositionSuffix: nextRepeatIndex });
-                // Find the last index of this section group
-                let insertAtIndex = index;
-                for (let i = index + 1; i < this.dynamicSections.length; i++) {
-                    const s = this.dynamicSections[i];
-                    if (s.name === cloningSectionName) {
-                        insertAtIndex = i;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                // Insert after the last repeat of the section group
-                this.dynamicSections = [
-                    ...this.dynamicSections.slice(0, insertAtIndex + 1),
-                    clonedSection,
-                    ...this.dynamicSections.slice(insertAtIndex + 1),
-                ];
-                // Create new initial values structure
-                const newInitialValues = structuredClone(this.udpFormSubmission.data.submissionResponseData);
-                clonedSection.formQuestions.forEach(q => {
-                    var _a, _b, _c, _d;
-                    const newSectionNameWithSuffix = `${cloningSectionName}_${nextRepeatIndex}`;
-                    const newQuestionName = q.name;
-                    if (!newInitialValues[newSectionNameWithSuffix]) {
-                        newInitialValues[newSectionNameWithSuffix] = {};
-                    }
-                    // Preserve only Paragraph values from the source section; clear others
-                    let value = '';
-                    if (q.fieldTypeId === UdpFormsFieldTypeEnum.Paragraph) {
-                        // Determine source section key (the section being duplicated)
-                        const sourceSectionKey = sectionToClone.isOriginalSection
-                            ? cloningSectionName
-                            : `${cloningSectionName}_${sectionToClone.sectionPositionSuffix}`;
-                        const sourceVal = (_c = (_b = (_a = this.udpFormSubmission.data.submissionResponseData) === null || _a === void 0 ? void 0 : _a[sourceSectionKey]) === null || _b === void 0 ? void 0 : _b[newQuestionName]) === null || _c === void 0 ? void 0 : _c.value;
-                        let fieldProps = q === null || q === void 0 ? void 0 : q.fieldProperties;
-                        if (typeof fieldProps === 'string') {
-                            try {
-                                fieldProps = JSON.parse(fieldProps || '{}');
-                            }
-                            catch (_e) {
-                                fieldProps = {};
-                            }
-                        }
-                        const paragraphDefault = (_d = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.paragraphText) !== null && _d !== void 0 ? _d : '';
-                        value = sourceVal !== null && sourceVal !== void 0 ? sourceVal : paragraphDefault;
-                    }
-                    newInitialValues[newSectionNameWithSuffix][newQuestionName] = { value, comments: [], metadata: {} };
+                const { nextDynamicSections, nextValues } = computeDuplicateRepeatableSection({
+                    dynamicSections: this.dynamicSections,
+                    values: structuredClone(this.udpFormSubmission.data.submissionResponseData || {}),
+                    index,
                 });
-                // This will trigger a complete form re-render
-                this.initialValues = Object.assign({}, newInitialValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newInitialValues);
+                this.dynamicSections = nextDynamicSections;
+                this.currentValues = Object.assign({}, nextValues);
+                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, nextValues);
                 this.triggerFormRerender();
             }
             finally {
                 this.isUpdatingSections = false;
                 this.isLoading = false;
-                this.isUserUpdatedSections = true;
+                this.hasUnsavedChanges = true;
             }
         };
         /**
@@ -149,137 +103,90 @@ export class UdpFormsRenderer {
             this.isUpdatingSections = true;
             this.isLoading = true;
             try {
-                const deleteSectionName = sectionToDelete.name;
-                const deleteSuffix = sectionToDelete.sectionPositionSuffix;
-                const sectionKeyToDelete = `${deleteSectionName}_${deleteSuffix}`;
-                const newInitialValues = Object.assign({}, this.udpFormSubmission.data.submissionResponseData);
-                delete newInitialValues[sectionKeyToDelete];
-                // Remove the section from dynamicSections
-                const updatedSections = structuredClone(this.dynamicSections);
-                updatedSections.splice(index, 1);
-                // Shift all later repeatable sections backward by 1
-                updatedSections.forEach(section => {
-                    if (section.name !== deleteSectionName ||
-                        section.isOriginalSection ||
-                        section.sectionPositionSuffix <= deleteSuffix) {
-                        return;
-                    }
-                    const oldSuffix = section.sectionPositionSuffix;
-                    const oldSectionKey = `${deleteSectionName}_${oldSuffix}`;
-                    const newSuffix = oldSuffix - 1;
-                    const newSectionKey = `${deleteSectionName}_${newSuffix}`;
-                    // Update suffix
-                    section.sectionPositionSuffix = newSuffix;
-                    // Update questionIdentifierKeys
-                    section.formQuestions = section.formQuestions.map(q => {
-                        const newSectionQuestion = structuredClone(q);
-                        newSectionQuestion.questionIdentifierKey = `${newSectionKey}.${q.name}`;
-                        return newSectionQuestion;
-                    });
-                    // Move data in initial values
-                    if (newInitialValues[oldSectionKey]) {
-                        newInitialValues[newSectionKey] = structuredClone(newInitialValues[oldSectionKey]);
-                        delete newInitialValues[oldSectionKey];
-                    }
+                const { nextDynamicSections, nextValues } = computeDeleteRepeatableSection({
+                    dynamicSections: this.dynamicSections,
+                    values: Object.assign({}, (this.udpFormSubmission.data.submissionResponseData || {})),
+                    index,
                 });
-                this.dynamicSections = updatedSections;
-                this.initialValues = Object.assign({}, newInitialValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newInitialValues);
+                this.dynamicSections = nextDynamicSections;
+                this.currentValues = Object.assign({}, nextValues);
+                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, nextValues);
                 this.triggerFormRerender();
             }
             finally {
                 this.isUpdatingSections = false;
                 this.isLoading = false;
-                this.isUserUpdatedSections = true;
+                this.hasUnsavedChanges = true;
             }
         };
         /**
          * Auto save (background save)
          */
         this.performBackgroundSaveAndUpdateLocalSubmissionState = async (values) => {
-            var _a;
-            this.saveErrorMessage = null;
+            return this.performBackgroundSaveAndUpdateLocalSubmissionStateInternal(values);
+        };
+        this.performBackgroundSaveAndUpdateLocalSubmissionStateInternal = async (values, opts) => {
+            var _a, _b;
+            const allowUrlReplace = (_a = opts === null || opts === void 0 ? void 0 : opts.allowUrlReplace) !== null && _a !== void 0 ? _a : !this.isPublic;
+            const forceCreateDraftIfMissingId = (_b = opts === null || opts === void 0 ? void 0 : opts.forceCreateDraftIfMissingId) !== null && _b !== void 0 ? _b : false;
+            // Public mode: disable draft save flows by default
+            if (this.isPublic && !this.publicFeatures.allowDraftSave && !forceCreateDraftIfMissingId) {
+                return;
+            }
             try {
-                const updatedUdpFormSubmission = await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
-                this.udpFormSubmission = updatedUdpFormSubmission;
-                this.initialValues = Object.assign({}, (((_a = updatedUdpFormSubmission.data) === null || _a === void 0 ? void 0 : _a.submissionResponseData) || {}));
-                if (!new URLSearchParams(window.location.search).has('udpf_submissionId')) {
+                await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
+                await this.refreshSubmissionAndSyncState();
+                if (allowUrlReplace && !new URLSearchParams(window.location.search).has('udpf_submissionId')) {
                     // replace the current entry's query string with udpf_submissionId without needing to know the path
-                    this.replaceUrlWithSubmissionId(updatedUdpFormSubmission.id);
+                    replaceUrlWithSubmissionId(this.udpFormSubmission.id, this.history);
                 }
             }
             catch (error) {
-                this.saveErrorMessage = 'Failed to save form data';
             }
             finally {
                 this.isSaving = false;
-                this.isUserUpdatedSections = false;
-                this.isFormDirty = false;
+                this.hasUnsavedChanges = false;
             }
         };
+        this.refreshSubmissionAndSyncState = async () => {
+            var _a, _b;
+            if (!((_a = this.udpFormSubmission) === null || _a === void 0 ? void 0 : _a.id))
+                return;
+            const updated = await this.formSubmissionHandler.fetchAndPopulateUdpFormSubmissionObj(this.udpFormSubmission);
+            this.udpFormSubmission = updated;
+            this.currentValues = Object.assign({}, (((_b = updated.data) === null || _b === void 0 ? void 0 : _b.submissionResponseData) || {}));
+            this.isSubmitted = updated.status === UdpFormsSubmissionStatusEnum.Submitted;
+        };
         /**
-         * Handle the user saving or deleting a comment
+         * Handle the user saving or deleting a comment (pre-submit, private forms only)
          */
-        this.handleCommmentUpdate = async (values) => {
-            var _a;
-            this.isSaving = true;
-            this.saveErrorMessage = null;
-            try {
-                const updatedUdpFormSubmission = await this.formSubmissionHandler.saveFormSubmissionComments(values, this.udpFormSubmission);
-                this.udpFormSubmission = updatedUdpFormSubmission;
-                this.initialValues = Object.assign({}, (((_a = updatedUdpFormSubmission.data) === null || _a === void 0 ? void 0 : _a.submissionResponseData) || {}));
-                this.enqueueSnackbar('Saved sucessfully.', {
-                    variant: 'success',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
-            }
-            catch (error) {
-                this.enqueueSnackbar('There was an error saving.', {
-                    variant: 'error',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
-            }
-            finally {
-                this.isSaving = false;
-                this.isUserUpdatedSections = false;
-                this.isFormDirty = false;
-            }
-        };
+        // NOTE: comment saves for non-submitted owner flows are now handled by the standard
+        // draft save path (manual/background save). Dedicated comment endpoints are used
+        // only for:
+        // 1) submitted submissions, OR
+        // 2) non-owner viewers adding/updating/deleting comments.
         /**
-         * Manual save function - debounced to 5 seconds
+         * Manual save function - debounced to 5 seconds (private forms only)
          */
         this.handleManualSave = async (values) => {
-            // Only save if handler supports it and user is authenticated
-            // if (!this.formSubmissionHandler.supportsAutoSave() || !this.userId || !this.formSubmissionHandler.saveCurrentFormSubmissionState) {
-            //   return;
-            // }
-            var _a;
+            if (this.isPublic && !this.publicFeatures.allowDraftSave)
+                return;
             this.isSaving = true;
-            this.saveErrorMessage = null;
             try {
-                const updatedUdpFormSubmission = await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
-                this.udpFormSubmission = updatedUdpFormSubmission;
-                this.initialValues = Object.assign({}, (((_a = updatedUdpFormSubmission.data) === null || _a === void 0 ? void 0 : _a.submissionResponseData) || {}));
+                await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
+                await this.refreshSubmissionAndSyncState();
                 if (!new URLSearchParams(window.location.search).has('udpf_submissionId')) {
                     // replace the current entry's query string with udpf_submissionId without needing to know the path
-                    this.replaceUrlWithSubmissionId(updatedUdpFormSubmission.id);
+                    replaceUrlWithSubmissionId(this.udpFormSubmission.id, this.history);
                 }
-                this.enqueueSnackbar('Form saved successfully.', {
-                    variant: 'success',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
+                enqueueSnackbarSuccess('Form saved successfully.', this.enqueueSnackbar);
             }
             catch (error) {
-                this.enqueueSnackbar('There was an error saving this form', {
-                    variant: 'error',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
-                this.saveErrorMessage = 'Failed to save form data';
+                enqueueSnackbarError('There was an error saving this form', this.enqueueSnackbar);
             }
             finally {
                 this.isSaving = false;
-                this.isUserUpdatedSections = false;
-                this.isFormDirty = false;
+                this.hasUnsavedChanges = false;
             }
         };
         this.handleFormChange = (values) => {
@@ -309,7 +216,7 @@ export class UdpFormsRenderer {
             // create a new follow up form submission instance wiht a link to the parent form submission
             const followUpMasterForm = await this.formHandler.getFormByFormIdAndFormVersion(followUpFormId, followUpFormVersion);
             const followUpSubmissionData = {
-                submissionResponseData: buildEmptyInitialValues(followUpMasterForm),
+                submissionResponseData: buildEmptyCurrentValues(followUpMasterForm),
                 submissionMetadata: {
                     ParentSubmission: {
                         submissionId: parentFormSubmissionId,
@@ -346,7 +253,9 @@ export class UdpFormsRenderer {
             // Listen for launchFollowUpFormSideSheet event from udp-question
             this.el.addEventListener('launchFollowUpFormSideSheet', (e) => this.handleLaunchFollowUpFormSideSheet(e));
             this.el.addEventListener('formDirtyChange', (e) => {
-                this.isFormDirty = e.detail;
+                // Preserve any previously-detected unsaved changes (e.g. repeatable section add/delete)
+                // so a later false emission doesn't hide the save icon.
+                this.hasUnsavedChanges = this.hasUnsavedChanges || e.detail;
             });
         }
     }
@@ -355,17 +264,24 @@ export class UdpFormsRenderer {
         this.isLoading = true;
         try {
             // Get client user info if available
-            const user = (_a = this.getUserCallback) === null || _a === void 0 ? void 0 : _a.call(this);
-            if (user) {
-                this.clientUserInfo.id = user.id || null;
-                this.clientUserInfo.displayName = user.name || null;
-                this.clientUserInfo.email = user.email || null;
+            if (this.isPublic) {
+                this.clientUserInfo.id = '00000000-0000-0000-0000-000000000001';
+                this.clientUserInfo.displayName = 'Anonymous';
+            }
+            else {
+                const user = (_a = this.getUserCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+                if (user) {
+                    this.clientUserInfo.id = user.id || null;
+                    this.clientUserInfo.displayName = user.name || null;
+                    this.clientUserInfo.email = user.email || null;
+                }
             }
             this.formSubmissionHandler = FormSubmissionHandlerFactory.create(this.isPublic, this.clientUserInfo.id);
-            this.udpFormSubmission = new UdpFormSubmission({ id: this.submissionId, formId: this.formId, formVersion: this.version, unityUserId: this.clientUserInfo.id, generic1: this.generic1, generic2: this.generic2, generic3: this.generic3 });
+            this.udpFormSubmission = new UdpFormSubmission({ id: this.submissionId, formId: this.formId, formVersion: this.version, unityUserId: this.clientUserInfo.id, generic1: this.urlContext.generic1, generic2: this.urlContext.generic2, generic3: this.urlContext.generic3 });
             // fetch existing submission from Udp.FormSubmission if submissionId is provided 
             // take exisitng object, and populate with db values, and return new obj with updated values
             if (this.submissionId) {
+                // Public users should not open private forms; we rely on backend auth to block.
                 this.udpFormSubmission = await this.formSubmissionHandler.fetchAndPopulateUdpFormSubmissionObj(this.udpFormSubmission);
             }
             // get the master form from Udp.Form
@@ -382,18 +298,29 @@ export class UdpFormsRenderer {
             this.formHandler = new UdpFormHandler(this.tenantId);
             const formData = await this.formHandler.getFormByFormIdAndFormVersion(formId, formVersion);
             this.udpForm = new UdpForm(formData);
-            this.initialValues = buildEmptyInitialValues(this.udpForm);
+            this.currentValues = buildEmptyCurrentValues(this.udpForm);
             // if there's existing data, update the form's state
             if (this.udpFormSubmission.data.submissionResponseData) {
-                this.initialValues = Object.assign({}, this.udpFormSubmission.data.submissionResponseData);
-                if (this.udpFormSubmission.status === 2 || this.udpFormSubmission.status === 'submitted') {
+                this.currentValues = Object.assign({}, this.udpFormSubmission.data.submissionResponseData);
+                if (this.udpFormSubmission.status === UdpFormsSubmissionStatusEnum.Submitted) {
                     this.isSubmitted = true;
                 }
             }
-            this.initializeDynamicSections(); // process the master form into dynamic sections 
-            // After sections/questions are prepared, seed initial values from URL for ALL questions,
-            // with saved values taking precedence, and paragraph defaults as a fallback.
-            this.applyUrlInitialValuesForAll();
+            // For new submissions (un-instiantiated or in the 'created' status), we allow the seeding of initial values from URL params
+            // So we build dynamicSections with urlContext first, then seed values.
+            // URL params (udpf_*) may imply repeatable section instances (e.g. section1_3.question1).
+            // For existing submissions that are in progress, skip URL-based seeding and do not create additional sections from URL.
+            if ((!this.udpFormSubmission.id || this.udpFormSubmission.status === UdpFormsSubmissionStatusEnum.Created) && this.urlContext && Object.keys(this.urlContext).length > 0) {
+                this.dynamicSections = initializeDynamicSectionsWithUrlContext(this.udpForm, this.currentValues, this.urlContext);
+                const seeded = applyUrlSeedValuesForAll(this.dynamicSections, this.urlContext);
+                if (seeded) {
+                    this.currentValues = seeded;
+                    this.udpFormSubmission.data.submissionResponseData = Object.assign({}, seeded);
+                }
+            }
+            else {
+                this.dynamicSections = initializeDynamicSections(this.udpForm, this.currentValues);
+            }
             // Set up throttled manual save function (5 seconds) - fires immediately, then throttles
             this.debouncedManualSave = throttle(async (values) => {
                 await this.handleManualSave(values);
@@ -410,290 +337,120 @@ export class UdpFormsRenderer {
             this.isLoading = false;
         }
     }
-    // build dynamic sections based on the
-    initializeDynamicSections() {
-        var _a;
-        const tempDynamicSection = [];
-        const sortedSections = structuredClone(this.udpForm.udpFormUdpFormSection).sort((a, b) => a.order - b.order);
-        for (const section of sortedSections) {
-            section.sectionProperties = JSON.parse(section.sectionProperties || {});
-            const repeatGroupKeys = this.findRepeatGroupKeys(section.name, this.initialValues);
-            section.isOriginalSection = true;
-            section.sectionPositionSuffix = 1; // default position
-            // always add the original section into dynamic sections
-            tempDynamicSection.push(Object.assign(Object.assign({}, structuredClone(section)), {
-                // dynamicSectionName: section.name,
-                formQuestions: structuredClone(this.udpForm.formQuestions)
-                    .filter(q => q.formSectionId === section.id)
-                    .sort((a, b) => a.questionOrder - b.questionOrder)
-                    .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}.${q.name}`, isShowCommentInput: true })))
-            }));
-            // create then add additional sections if there are repeated sections
-            if (((_a = section.sectionProperties) === null || _a === void 0 ? void 0 : _a.isRepeatable) && repeatGroupKeys.length > 0) {
-                const maxRepeatedSectionSuffix = Math.max(...repeatGroupKeys); // create a new section for the max value of repeat group keys, even if there are no saved answers
-                // for (const repeatKey of repeatGroupKeys) { // create a section only for the suffix saved
-                for (let repeatKey = 2; repeatKey <= maxRepeatedSectionSuffix; repeatKey++) {
-                    const clonedSection = Object.assign(Object.assign({}, structuredClone(section)), { formQuestions: structuredClone(this.udpForm.formQuestions)
-                            .filter(q => q.formSectionId === section.id)
-                            .sort((a, b) => a.questionOrder - b.questionOrder)
-                            .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}_${repeatKey}.${q.name}`, isShowCommentInput: true }))), isOriginalSection: false, sectionPositionSuffix: repeatKey });
-                    tempDynamicSection.push(clonedSection);
-                }
-            }
-        }
-        this.dynamicSections = tempDynamicSection;
-    }
-    findRepeatGroupKeys(sectionName, values) {
-        const keys = Object.keys(values);
-        const repeatGroupSet = new Set();
-        // Match: sectionName_2
-        const regex = new RegExp(`^${sectionName}_(\\d+)`);
-        keys.forEach(key => {
-            const match = key.match(regex);
-            if (match && match[1]) {
-                repeatGroupSet.add(Number(match[1]));
-            }
-        });
-        return Array.from(repeatGroupSet).sort((a, b) => a - b);
-    }
-    // Build initial values from URL for ALL fields, but do NOT override saved values.
-    // For Paragraph, also fall back to the builder's default text when nothing else provided.
-    applyUrlInitialValuesForAll() {
-        if (!Array.isArray(this.dynamicSections))
-            return;
-        const urlParams = typeof window !== 'undefined' ? new URLSearchParams(window.location.search) : null;
-        // 1) Collect URL values into nested structure: { [sectionKey]: { [questionName]: { value, comments: [] } } }
-        const urlValuesNested = {};
-        if (urlParams) {
-            this.dynamicSections.forEach(section => {
-                const sectionKey = section.isOriginalSection
-                    ? section.name
-                    : `${section.name}_${section.sectionPositionSuffix}`;
-                (section.formQuestions || []).forEach(q => {
-                    if (!q)
-                        return;
-                    const candidates = [q.processedSubmissionName, q.questionIdentifierKey, q.name].filter(Boolean);
-                    let urlVal = null;
-                    for (const c of candidates) {
-                        urlVal = urlParams.get(c);
-                        if (urlVal !== null)
-                            break;
-                    }
-                    if (urlVal !== null) {
-                        if (!urlValuesNested[sectionKey])
-                            urlValuesNested[sectionKey] = {};
-                        urlValuesNested[sectionKey][q.name] = { value: urlVal, comments: [] };
-                    }
-                });
-            });
-        }
-        // 2) Merge with saved values (this.initialValues) taking precedence
-        const merged = structuredClone(this.initialValues) || {};
-        Object.entries(urlValuesNested).forEach(([sectionKey, qMap]) => {
-            if (!merged[sectionKey])
-                merged[sectionKey] = {};
-            Object.entries(qMap).forEach(([qName, valObj]) => {
-                const existing = merged[sectionKey][qName];
-                // Only set from URL if no saved value exists (null/undefined/empty-string)
-                const isMissing = existing == null ||
-                    existing.value == null ||
-                    (typeof existing.value === 'string' && existing.value.trim() === '');
-                if (isMissing) {
-                    merged[sectionKey][qName] = valObj;
-                }
-            });
-        });
-        // 3) Paragraph defaults: if still undefined/null, use fieldProperties.paragraphText
-        this.dynamicSections.forEach(section => {
-            const sectionKey = section.isOriginalSection
-                ? section.name
-                : `${section.name}_${section.sectionPositionSuffix}`;
-            if (!merged[sectionKey])
-                merged[sectionKey] = {};
-            (section.formQuestions || []).forEach(q => {
-                var _a;
-                if (!q)
-                    return;
-                if (q.fieldTypeId === UdpFormsFieldTypeEnum.Paragraph) {
-                    const existing = merged[sectionKey][q.name];
-                    const isMissing = existing == null ||
-                        existing.value == null ||
-                        (typeof existing.value === 'string' && existing.value.trim() === '');
-                    if (isMissing) {
-                        let fieldProps = q === null || q === void 0 ? void 0 : q.fieldProperties;
-                        if (typeof fieldProps === 'string') {
-                            try {
-                                fieldProps = JSON.parse(fieldProps || '{}');
-                            }
-                            catch (_b) {
-                                fieldProps = {};
-                            }
-                        }
-                        merged[sectionKey][q.name] = {
-                            value: (_a = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.paragraphText) !== null && _a !== void 0 ? _a : '',
-                            comments: [],
-                        };
-                    }
-                }
-            });
-        });
-        this.initialValues = merged;
-        this.udpFormSubmission.data.submissionResponseData = Object.assign({}, merged);
-    }
     async handleSubmit(values) {
         this.isLoading = true;
         try {
-            this.udpFormSubmission = await this.formSubmissionHandler.finalizeFormSubmissionState(values, this.udpFormSubmission);
+            await this.formSubmissionHandler.finalizeFormSubmissionState(values, this.udpFormSubmission);
+            await this.refreshSubmissionAndSyncState();
             this.submitSuccessful = true;
         }
         catch (error) {
-            this.enqueueSnackbar('There was an error submitting this form', {
-                variant: 'error',
-                anchorOrigin: { vertical: 'top', horizontal: 'center' },
-            });
+            enqueueSnackbarError('There was an error submitting this form', this.enqueueSnackbar);
             throw error;
         }
         finally {
             this.isLoading = false;
         }
     }
-    replaceUrlWithSubmissionId(submissionId) {
-        // build a URL that preserves the current pathname + hash but replaces the query string
-        const pathname = typeof window !== 'undefined' ? window.location.pathname : `/page/${UdpFormsPageIdEnum.FormRendererPageId}`;
-        const hash = typeof window !== 'undefined' ? window.location.hash : '';
-        const newUrl = `${pathname}?udpf_submissionId=${submissionId}${hash}`;
-        const h = this.history;
-        // Prefer history.replace when available, handle react-router v6 navigate function, fallback to push or native replaceState
-        if (h) {
-            if (typeof h.replace === 'function') {
-                h.replace(newUrl);
-                return;
-            }
-            if (typeof h.push === 'function') {
-                h.push(newUrl);
-                return;
-            }
-            // react-router v6 exposes a navigate function
-            if (typeof h === 'function') {
-                try {
-                    h(newUrl, { replace: true });
-                }
-                catch (_a) {
-                    h(newUrl);
-                }
-                return;
-            }
-        }
-        if (typeof window !== 'undefined' && window.history && typeof window.history.replaceState === 'function') {
-            window.history.replaceState({}, '', newUrl);
-        }
-        else if (typeof window !== 'undefined') {
-            window.location.href = newUrl;
-        }
-    }
     async handleQuestionCommentLiveCRUD(e) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
+        if (this.isPublic && !this.publicFeatures.allowComments)
+            return;
         try {
             const { type, questionIdentifierKey, commentId } = e.detail;
-            const [sectionName, questionName] = questionIdentifierKey.split('.');
-            let newInitialValues = structuredClone(this.udpFormSubmission.data.submissionResponseData || {});
-            // ensure structure exists WITHOUT overwriting existing data
-            if (!newInitialValues[sectionName])
-                newInitialValues[sectionName] = {};
-            if (!newInitialValues[sectionName][questionName]) {
-                // create defaults but do not clobber any existing saved shape from submissionResponseData
-                newInitialValues[sectionName][questionName] = {
-                    value: '',
-                    comments: [],
-                    draftComments: [],
-                    metadata: {},
-                };
-            }
-            else {
-                // ensure arrays/objects exist so later code can safely push/filter
-                newInitialValues[sectionName][questionName].comments = (_a = newInitialValues[sectionName][questionName].comments) !== null && _a !== void 0 ? _a : [];
-                newInitialValues[sectionName][questionName].draftComments = (_b = newInitialValues[sectionName][questionName].draftComments) !== null && _b !== void 0 ? _b : [];
-                newInitialValues[sectionName][questionName].metadata = (_c = newInitialValues[sectionName][questionName].metadata) !== null && _c !== void 0 ? _c : {};
-            }
-            // normalize draftComments to array if needed (back-compat)
-            const maybeDraft = newInitialValues[sectionName][questionName].draftComments;
-            if (maybeDraft && !Array.isArray(maybeDraft)) {
-                newInitialValues[sectionName][questionName].draftComments = [maybeDraft];
-            }
-            else if (!maybeDraft) {
-                newInitialValues[sectionName][questionName].draftComments = [];
+            const result = applyQuestionCommentCrud({
+                actionType: type,
+                questionIdentifierKey,
+                commentId,
+                currentSubmissionResponseData: this.udpFormSubmission.data.submissionResponseData || {},
+                clientUserInfo: this.clientUserInfo,
+            });
+            const newCurrentValues = result.nextSubmissionResponseData;
+            // keep submission state in sync
+            this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newCurrentValues);
+            // Edit-ish actions are UI-only (open/close draft editor). They must update currentValues
+            // even though they don't persist.
+            if (type === 'edit' || type === 'editClose' || type === 'add') {
+                this.currentValues = Object.assign({}, newCurrentValues);
             }
-            const commentsArr = newInitialValues[sectionName][questionName].comments || [];
-            const draftsArr = newInitialValues[sectionName][questionName].draftComments || [];
-            switch (type) {
-                case 'add': {
-                    const newDraft = {
-                        value: '',
-                        commentId: uuidv4(),
-                        isTempComment: true,
-                        timestamp: null,
-                    };
-                    // put new draft first so activeDraft === draftComments[0] matches UX
-                    newInitialValues[sectionName][questionName].draftComments = [newDraft, ...draftsArr];
-                    break;
-                }
-                case 'save': {
-                    // find draft by id
-                    const draftIdx = draftsArr.findIndex(d => d.commentId === commentId);
-                    if (draftIdx === -1)
-                        return;
-                    const draft = draftsArr[draftIdx];
-                    const saveTimestamp = draft.timestamp || new Date().toISOString();
-                    const savedComment = Object.assign(Object.assign({}, draft), { timestamp: saveTimestamp, editedTimestamp: new Date().toISOString(), userId: this.clientUserInfo.id, userDisplayName: this.clientUserInfo.displayName, isDraftComment: false });
-                    // If a saved comment with same id exists, replace it. Otherwise append.
-                    const existingIdx = commentsArr.findIndex(c => c.commentId === commentId);
-                    if (existingIdx !== -1) {
-                        const newComments = [...commentsArr];
-                        newComments[existingIdx] = Object.assign({}, savedComment);
-                        newInitialValues[sectionName][questionName].comments = newComments;
+            // if it's a save or delete action, persist immediately
+            if (result.shouldPersist) {
+                const submissionIsSubmitted = ((_a = this.udpFormSubmission) === null || _a === void 0 ? void 0 : _a.status) === UdpFormsSubmissionStatusEnum.Submitted;
+                const submissionIsOwnedByCurrentUser = ((_b = this.udpFormSubmission) === null || _b === void 0 ? void 0 : _b.unityUserId) === this.clientUserInfo.id;
+                // Detect whether this save is updating an existing saved comment vs creating a new one.
+                // IMPORTANT: check against the *previous* persisted state (before applyQuestionCommentCrud),
+                // because once we apply 'save' locally the comment will exist locally even if it's new.
+                const existingSavedComment = (((_e = (_d = (_c = ((this.currentValues || {}))) === null || _c === void 0 ? void 0 : _c[result.sectionKey]) === null || _d === void 0 ? void 0 : _d[result.questionKey]) === null || _e === void 0 ? void 0 : _e.comments) || [])
+                    .find((c) => (c === null || c === void 0 ? void 0 : c.commentId) === result.commentId && !(c === null || c === void 0 ? void 0 : c.isDeleted));
+                // Use dedicated comment APIs in 2 scenarios:
+                // 1) Once submitted (public+private) to avoid overwriting submission data.
+                // 2) When viewed by a non-owner (read-only mode), since they can't save the whole submission.
+                if (submissionIsSubmitted || !submissionIsOwnedByCurrentUser) {
+                    if (!((_f = this.udpFormSubmission) === null || _f === void 0 ? void 0 : _f.id)) {
+                        // can't persist without an ID; keep local only
+                        this.currentValues = Object.assign({}, newCurrentValues);
                     }
-                    else {
-                        newInitialValues[sectionName][questionName].comments = [...commentsArr, savedComment];
+                    else if (type === 'save') {
+                        const valueToPersist = result.valueToPersist;
+                        if (valueToPersist) {
+                            try {
+                                // If this comment already exists, update it; otherwise add it.
+                                if (existingSavedComment) {
+                                    await this.formSubmissionHandler.updateComment(this.udpFormSubmission, {
+                                        sectionKey: result.sectionKey,
+                                        questionKey: result.questionKey,
+                                        value: valueToPersist,
+                                        commentId: result.commentId,
+                                    });
+                                }
+                                else {
+                                    await this.formSubmissionHandler.addComment(this.udpFormSubmission, {
+                                        sectionKey: result.sectionKey,
+                                        questionKey: result.questionKey,
+                                        value: valueToPersist,
+                                        commentId: result.commentId,
+                                    });
+                                }
+                                await this.refreshSubmissionAndSyncState();
+                                enqueueSnackbarSuccess(existingSavedComment ? 'Comment updated.' : 'Comment added.', this.enqueueSnackbar);
+                            }
+                            catch (error) {
+                                enqueueSnackbarError(existingSavedComment ? 'Failed to update comment.' : 'Failed to add comment.', this.enqueueSnackbar);
+                                throw error;
+                            }
+                        }
                     }
-                    // remove that draft
-                    newInitialValues[sectionName][questionName].draftComments = draftsArr.filter(d => d.commentId !== commentId);
-                    break;
-                }
-                case 'edit': {
-                    // create a draft copy of the saved comment but DO NOT remove the saved comment from the list.
-                    const saved = commentsArr.find(c => c.commentId === commentId);
-                    if (!saved)
-                        return;
-                    const draftFromSaved = Object.assign(Object.assign({}, saved), { isDraftComment: true, timestamp: null });
-                    // Add this draft at the front; keep saved comment intact so content doesn't disappear.
-                    newInitialValues[sectionName][questionName].draftComments = [draftFromSaved, ...draftsArr];
-                    newInitialValues[sectionName][questionName].comments = commentsArr;
-                    break;
-                }
-                case 'delete': {
-                    // mark the comment as deleted and clear its value, then persist.
-                    newInitialValues[sectionName][questionName].comments = commentsArr.map(c => {
-                        if (c.commentId === commentId) {
-                            return Object.assign(Object.assign({}, c), { isDeleted: true, value: '', editedTimestamp: new Date().toISOString() });
+                    else if (type === 'delete') {
+                        try {
+                            await this.formSubmissionHandler.deleteComment(this.udpFormSubmission, {
+                                sectionKey: result.sectionKey,
+                                questionKey: result.questionKey,
+                                commentId: result.commentId,
+                            });
+                            await this.refreshSubmissionAndSyncState();
+                            enqueueSnackbarSuccess('Comment deleted.', this.enqueueSnackbar);
                         }
-                        return c;
-                    });
-                    break;
+                        catch (error) {
+                            enqueueSnackbarError('Failed to delete comment.', this.enqueueSnackbar);
+                            throw error;
+                        }
+                    }
                 }
-                case 'editClose': {
-                    // Cancel edit: remove the draft only, do NOT restore/alter saved comments.
-                    newInitialValues[sectionName][questionName].draftComments = draftsArr.filter(d => d.commentId !== commentId);
-                    break;
+                else {
+                    // Not submitted yet:
+                    // - public: persist nothing beyond local state (submission is created on submit)
+                    // - private + owner: comment edits are persisted via standard submission save
+                    if (this.isPublic) {
+                        this.currentValues = Object.assign({}, newCurrentValues);
+                    }
+                    else {
+                        await this.handleManualSave(newCurrentValues);
+                    }
                 }
             }
-            // if it's a save or delete action, persist immediately
-            if (type === 'save' || type === 'delete') {
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newInitialValues);
-                await this.handleCommmentUpdate(newInitialValues);
-            }
             else {
-                this.initialValues = Object.assign({}, newInitialValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newInitialValues);
+                // Non-persisting actions update UI state only
+                this.currentValues = Object.assign({}, newCurrentValues);
             }
         }
         catch (error) {
@@ -706,7 +463,6 @@ export class UdpFormsRenderer {
     async loadFollowUpForms(sectionKey, questionKey) {
         var _a;
         this.isLoading = true;
-        this.saveErrorMessage = '';
         try {
             const response = await fetchLatestForms(this.followUpSideSheetListPageNumber, this.FOLLOW_UP_SIDE_SHEET_PAGE_SIZE, [{ searchField: 'type', searchOperator: '=', searchValue: UdpFormsTypeEnum.FollowUp }], { sortDirection: 'DESC', sortColumn: 'lastModifiedOn' });
             const data = response.data;
@@ -718,7 +474,6 @@ export class UdpFormsRenderer {
         }
         catch (err) {
             console.error('Failed to follow up form.', err);
-            this.saveErrorMessage = 'Failed to follow up forms.';
         }
         finally {
             this.isLoading = false;
@@ -736,11 +491,17 @@ export class UdpFormsRenderer {
         await this.loadFollowUpForms(this.followUpParentSectionKey, this.followUpParentQuestionKey);
     }
     renderFollowUpSideSheet() {
+        if (this.isPublic)
+            return null;
         return (h("udp-side-sheet", { title: "Link a Follow Up Form", open: this.isFollowUpFormsSideSheetOpen, onUdpSideSheetClose: () => this.handleSideSheetClose(), position: "right", width: "md" }, this.isLoading && this.isFollowUpFormsSideSheetOpen && h("udp-linear-loader", null), h("udp-list-renderer", { itemComponent: "udp-forms-follow-up-list-card", data: this.sideSheetFollowUpFormsList, pagination: true, isServerSide: true, isLoading: this.isLoading, itemsPerPage: this.FOLLOW_UP_SIDE_SHEET_PAGE_SIZE, currentPage: this.followUpSideSheetListPageNumber, totalItems: this.followUpSideSheetTotalItems, onPageChange: e => this.handleSideSheetPageChange(e.detail), componentDataMap: this.componentMap, spacing: 'md' })));
     }
     isShowManualSaveIcon() {
-        // return (this.isFormDirty || this.isUserUpdatedSections) && !this.isSubmitted && !!this.userId;
-        const showSaveIcon = (this.isFormDirty || this.isUserUpdatedSections) && !!this.clientUserInfo.id;
+        if (this.isPublic)
+            return false; // cannot save a form in public mode. can only submit. 
+        // NOTE: repeatable section add/delete sets hasUnsavedChanges=true, but udp-forms-ui likely
+        // also emits a formDirtyChange event that can override the value back to false.
+        // Keep the save icon sticky once we've detected any unsaved change.
+        const showSaveIcon = !!this.clientUserInfo.id && (this.hasUnsavedChanges);
         return showSaveIcon;
     }
     ;
@@ -748,7 +509,8 @@ export class UdpFormsRenderer {
         return this.isSubmitted || this.udpFormSubmission.unityUserId !== this.clientUserInfo.id;
     }
     render() {
-        return (h("div", { key: 'c0adb1a4f78f6ff15ce946b44677820f716e8a86', class: "forms-renderer-container", style: this.isLoading ? { minHeight: '100vh' } : {} }, this.renderFollowUpSideSheet(), h("udp-forms-ui", { udpForm: this.udpForm, initialValues: this.initialValues, udpFormSubmission: this.udpFormSubmission, submitSuccessful: this.submitSuccessful, isSaving: this.isSaving, saveErrorMessage: this.saveErrorMessage,
+        return (h("div", { key: '37ec47fc7f3ecec70ba7ca3e12717789285be5d8', class: "forms-renderer-container", style: this.isLoading ? { minHeight: '100vh' } : {} }, this.renderFollowUpSideSheet(), h("udp-forms-ui", { udpForm: this.udpForm, currentValues: this.currentValues, udpFormSubmission: this.udpFormSubmission, submitSuccessful: this.submitSuccessful, isSaving: this.isSaving,
+            // saveErrorMessage={this.saveErrorMessage}
             // showAutoSaveStatus={this.formSubmissionHandler.supportsAutoSave() && !!this.userId}
             readonly: this.isReadOnlyMode, handleSubmit: this.handleSubmit.bind(this), handleSave: values => Promise.resolve(this.debouncedManualSave(values)), handleChange: this.handleFormChange, handleAction: this.triggerAction, handleFinish: this.handleFinish, clientUserInfo: this.clientUserInfo, isSubmitted: this.isSubmitted, dynamicSections: this.dynamicSections, duplicateRepeatableSection: this.duplicateRepeatableSection, deleteRepeatableSection: this.deleteRepeatableSection, key: `form-rerender-key-${this.reRenderKey}`, isShowManualSaveIcon: this.isShowManualSaveIcon(), isLoading: this.isLoading, performBackgroundSaveAndUpdateLocalSubmissionState: this.performBackgroundSaveAndUpdateLocalSubmissionState })));
     }
@@ -766,7 +528,8 @@ export class UdpFormsRenderer {
                         "Guid": {
                             "location": "import",
                             "path": "src/global/types",
-                            "id": "src/global/types.ts::Guid"
+                            "id": "src/global/types.ts::Guid",
+                            "referenceLocation": "Guid"
                         }
                     }
                 },
@@ -810,7 +573,8 @@ export class UdpFormsRenderer {
                         "Guid": {
                             "location": "import",
                             "path": "src/global/types",
-                            "id": "src/global/types.ts::Guid"
+                            "id": "src/global/types.ts::Guid",
+                            "referenceLocation": "Guid"
                         }
                     }
                 },
@@ -835,7 +599,8 @@ export class UdpFormsRenderer {
                         "Guid": {
                             "location": "import",
                             "path": "src/global/types",
-                            "id": "src/global/types.ts::Guid"
+                            "id": "src/global/types.ts::Guid",
+                            "referenceLocation": "Guid"
                         },
                         "Object": {
                             "location": "global",
@@ -996,51 +761,18 @@ export class UdpFormsRenderer {
                 "reflect": false,
                 "attribute": "history"
             },
-            "generic1": {
-                "type": "any",
-                "mutable": false,
-                "complexType": {
-                    "original": "any",
-                    "resolved": "any",
-                    "references": {}
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false,
-                "reflect": false,
-                "attribute": "generic-1"
-            },
-            "generic2": {
-                "type": "any",
-                "mutable": false,
-                "complexType": {
-                    "original": "any",
-                    "resolved": "any",
-                    "references": {}
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false,
-                "reflect": false,
-                "attribute": "generic-2"
-            },
-            "generic3": {
-                "type": "any",
+            "urlContext": {
+                "type": "unknown",
                 "mutable": false,
                 "complexType": {
-                    "original": "any",
-                    "resolved": "any",
-                    "references": {}
+                    "original": "Record<string, any>",
+                    "resolved": "any | string",
+                    "references": {
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
                 },
                 "required": false,
                 "optional": false,
@@ -1050,25 +782,21 @@ export class UdpFormsRenderer {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
-                "attribute": "generic-3"
+                "defaultValue": "{}"
             }
         };
     }
     static get states() {
         return {
-            "initialValues": {},
+            "currentValues": {},
             "submitSuccessful": {},
-            "currentFormData": {},
             "isLoading": {},
             "isSaving": {},
             "isSubmitted": {},
-            "saveErrorMessage": {},
             "dynamicSections": {},
             "isUpdatingSections": {},
             "reRenderKey": {},
-            "isFormDirty": {},
-            "isUserUpdatedSections": {},
+            "hasUnsavedChanges": {},
             "sideSheetFollowUpFormsList": {},
             "followUpSideSheetTotalItems": {},
             "isFollowUpFormsSideSheetOpen": {},
@@ -1077,4 +805,3 @@ export class UdpFormsRenderer {
     }
     static get elementRef() { return "el"; }
 }
-//# sourceMappingURL=udp-forms-renderer.js.map