@posthog/browser-common 0.9.5 → 0.9.6

package/dist/surveys-renderer.mjs

@@ -0,0 +1,1230 @@
+import { jsx, jsxs } from "preact/jsx-runtime";
+import { Fragment, createElement, render } from "preact";
+import { SURVEYS } from "./surveys-config.mjs";
+import { FeatureFlagsCommonExtension } from "./extension-tokens.mjs";
+import { getSurveyReplayUrl } from "./survey-render-context.mjs";
+import { uuidv7 } from "./utils/uuidv7.mjs";
+import { useContext, useEffect, useMemo, useRef, useState } from "preact/hooks";
+import { SurveyEventName, SurveyEventProperties, SurveyPosition, SurveyQuestionBranchingType, SurveyQuestionType, SurveySchedule, SurveyTabPosition, SurveyType, SurveyWidgetType } from "./survey-constants.mjs";
+import { addEventListener } from "./utils/general-utils.mjs";
+import { IN_APP_SURVEY_TYPES, SURVEY_CAPTURING_DISABLED, SURVEY_LOGGER, doesSurveyActivateByAction, doesSurveyActivateByEvent, isSurveyIterationBased, isSurveyRunning } from "./utils/survey-utils.mjs";
+import { isArray, isNull, isNumber, isUndefined } from "@posthog/core";
+import { recordSurveyAnswer } from "@posthog/core/surveys";
+import { ConfirmationMessage } from "./surveys/components/ConfirmationMessage.mjs";
+import { IntroScreen } from "./surveys/components/IntroScreen.mjs";
+import { Cancel } from "./surveys/components/QuestionHeader.mjs";
+import { LinkQuestion, MultipleChoiceQuestion, OpenTextQuestion, RatingQuestion } from "./surveys/components/QuestionTypes.mjs";
+import { SurveyContext, addSurveyCSSVariablesToElement, canActivateRepeatedly, clearAllInMemoryInProgressSurveyState, clearInProgressSurveyState, defaultSurveyAppearance, dismissedSurveyEvent, doesSurveyDeviceTypesMatch, doesSurveyMatchSelector, doesSurveyUrlMatch, getDisplayOrderQuestions, getInProgressSurveyState, getPopoverPosition, getQuestionOrder, getSurveyContainerClass, getSurveyResponseKey, getSurveySeen, getSurveyStylesheet, hasWaitPeriodPassed, isSurveyInProgress, retrieveSurveyShadow, sendSurveyAbandonedEvent, sendSurveyEvent, setInProgressSurveyState } from "./surveys/surveys-extension-utils.mjs";
+import { calculatePrefillStartIndex, convertPrefillToResponses, extractPrefillParamsFromUrl } from "./surveys/survey-url-prefill.mjs";
+import { getNextSurveyStep } from "./surveys/survey-branching.mjs";
+import { applySurveyTranslationForUser } from "./surveys/survey-translations.mjs";
+const INTRO_SCREEN_PREVIEW_INDEX = -1;
+const DISPATCH_FEEDBACK_WIDGET_EVENT = 'ph:show_survey_widget';
+const WIDGET_LISTENER_ATTRIBUTE = 'PHWidgetSurveyClickListener';
+const SURVEY_NEXT_TO_TRIGGER_PARAMS = {
+    ESTIMATED_MIN_HEIGHT: 250,
+    HORIZONTAL_PADDING: 20,
+    TRIGGER_SPACING: 12
+};
+function getNextToTriggerPosition(target, surveyWidth) {
+    try {
+        const buttonRect = target.getBoundingClientRect();
+        const viewportHeight = window.innerHeight;
+        const viewportWidth = window.innerWidth;
+        const estimatedMinSurveyHeight = SURVEY_NEXT_TO_TRIGGER_PARAMS.ESTIMATED_MIN_HEIGHT;
+        const buttonCenterX = buttonRect.left + buttonRect.width / 2;
+        let left = buttonCenterX - surveyWidth / 2;
+        const horizontalPadding = SURVEY_NEXT_TO_TRIGGER_PARAMS.HORIZONTAL_PADDING;
+        if (left + surveyWidth > viewportWidth - horizontalPadding) left = viewportWidth - surveyWidth - horizontalPadding;
+        if (left < horizontalPadding) left = horizontalPadding;
+        const spacing = SURVEY_NEXT_TO_TRIGGER_PARAMS.TRIGGER_SPACING;
+        const spaceBelow = viewportHeight - buttonRect.bottom;
+        const spaceAbove = buttonRect.top;
+        const showAbove = spaceBelow < estimatedMinSurveyHeight && spaceAbove > spaceBelow;
+        return {
+            position: 'fixed',
+            top: showAbove ? 'auto' : `${buttonRect.bottom + spacing}px`,
+            left: `${left}px`,
+            right: 'auto',
+            bottom: showAbove ? `${viewportHeight - buttonRect.top + spacing}px` : 'auto',
+            zIndex: defaultSurveyAppearance.zIndex
+        };
+    } catch (error) {
+        SURVEY_LOGGER.warn('Failed to calculate trigger position:', error);
+        return null;
+    }
+}
+const SURVEY_TARGETING_FLAG_PREFIX = 'survey-targeting-';
+class SurveyManager {
+    constructor(posthog){
+        this._surveyTimeouts = new Map();
+        this._widgetSelectorListeners = new Map();
+        this._renderedTabWidgets = new Map();
+        this._renderedTargets = new Map();
+        this._prefillHandledSurveys = new Set();
+        this._disposed = false;
+        this._currentLanguage = null;
+        this._surveyIsRendered = false;
+        this._languageChangeListener = null;
+        this._unsubscribeFeatureFlags = null;
+        this._surveyPopupProps = null;
+        this._loggedFeatureFlagsDisabledWarning = false;
+        this.handlePageUnload = ()=>{
+            const surveys = this._host.client?.kv.get(SURVEYS);
+            if (!surveys) return;
+            for (const survey of surveys)if (isSurveyInProgress(survey)) sendSurveyAbandonedEvent(survey, this._host);
+        };
+        this.handlePopoverSurvey = (surveyParam, options, { resumeDelayFromActivation = false } = {})=>{
+            if (!this._host.client?.canCapture) return;
+            const { survey: translatedSurvey, language: surveyLanguage } = this._translateSurveyForRendering(surveyParam);
+            this._currentLanguage = surveyLanguage;
+            this._surveyPopupProps = null;
+            this._displayOptions = options;
+            const survey = this._applyDisplayOverrides(translatedSurvey, options);
+            this._clearSurveyTimeout(survey.id);
+            const { properties, initialResponses } = options ?? {};
+            const hasPrefillData = initialResponses && Object.keys(initialResponses).length > 0;
+            const isSurveyCompleted = hasPrefillData ? this._handleInitialResponses(survey, initialResponses, properties, surveyLanguage) : false;
+            if (isSurveyCompleted && !survey.appearance?.displayThankYouMessage) return;
+            this._addSurveyToFocus(survey);
+            let positionStyle = {};
+            if (survey.appearance?.position === SurveyPosition.NextToTrigger && survey.appearance?.widgetSelector) {
+                const targetElement = document.querySelector(survey.appearance.widgetSelector);
+                if (targetElement) positionStyle = getNextToTriggerPosition(targetElement, parseInt(survey.appearance?.maxWidth || defaultSurveyAppearance.maxWidth)) || {};
+            }
+            const delaySeconds = survey.appearance?.surveyPopupDelaySeconds || 0;
+            const { shadow } = retrieveSurveyShadow(survey, this._host);
+            this._renderedTargets.set(shadow, shadow.host);
+            const surveyPopupProps = {
+                posthog: this._host,
+                survey: survey,
+                removeSurveyFromFocus: this._removeSurveyFromFocus,
+                properties: properties,
+                style: positionStyle,
+                isSurveyCompleted: isSurveyCompleted,
+                skipShownEvent: options?.skipShownEvent,
+                surveyLanguage
+            };
+            this._surveyPopupProps = surveyPopupProps;
+            if (delaySeconds <= 0) {
+                this._surveyIsRendered = true;
+                return render(/*#__PURE__*/ jsx(SurveyPopup, {
+                    ...surveyPopupProps
+                }), shadow);
+            }
+            const renderAfterDelay = ()=>{
+                this._surveyIsRendered = true;
+                const { survey: freshlyTranslated, language: freshLanguage } = this._translateSurveyForRendering(surveyParam);
+                this._currentLanguage = freshLanguage;
+                const freshSurvey = this._applyDisplayOverrides(freshlyTranslated, options);
+                const freshPopupProps = {
+                    ...surveyPopupProps,
+                    survey: freshSurvey,
+                    surveyLanguage: freshLanguage
+                };
+                this._surveyPopupProps = freshPopupProps;
+                render(/*#__PURE__*/ jsx(SurveyPopup, {
+                    ...freshPopupProps,
+                    survey: {
+                        ...freshSurvey,
+                        appearance: {
+                            ...freshSurvey.appearance,
+                            surveyPopupDelaySeconds: 0
+                        }
+                    }
+                }), shadow);
+            };
+            const renderIfStillEligible = ()=>{
+                if (!this._host.client?.canCapture || !this._shouldDisplaySurvey(survey)) {
+                    SURVEY_LOGGER.info(`Survey ${survey.id} no longer eligible when its display delay elapsed; not displaying`);
+                    return this._removeSurveyFromFocus(survey);
+                }
+                renderAfterDelay();
+            };
+            const activatedAt = resumeDelayFromActivation ? this._host.surveys?._surveyEventReceiver?.getActivationTimestamp?.(survey.id) : void 0;
+            const elapsedMs = isNumber(activatedAt) ? Math.max(0, Date.now() - activatedAt) : 0;
+            const remainingMs = Math.max(0, 1000 * delaySeconds - elapsedMs);
+            if (remainingMs <= 0) return renderIfStillEligible();
+            const timeoutId = window.setTimeout(()=>{
+                this._surveyTimeouts.delete(survey.id);
+                renderIfStillEligible();
+            }, remainingMs);
+            this._surveyTimeouts.set(survey.id, timeoutId);
+        };
+        this._handleWidget = (survey)=>{
+            const { survey: translatedSurvey, language: surveyLanguage } = this._translateSurveyForRendering(survey);
+            const { shadow, isNewlyCreated } = retrieveSurveyShadow(translatedSurvey, this._host);
+            this._renderedTargets.set(shadow, shadow.host);
+            if (survey.appearance?.widgetType === SurveyWidgetType.Tab) this._renderedTabWidgets.set(survey.id, survey);
+            if (!isNewlyCreated) return;
+            render(/*#__PURE__*/ jsx(FeedbackWidget, {
+                posthog: this._host,
+                survey: translatedSurvey,
+                surveyLanguage: surveyLanguage
+            }, survey.id), shadow);
+        };
+        this._detachWidgetSelectorListener = (surveyId)=>{
+            const existing = this._widgetSelectorListeners.get(surveyId);
+            if (existing) {
+                existing.element.removeEventListener('click', existing.listener);
+                existing.element.removeAttribute(WIDGET_LISTENER_ATTRIBUTE);
+                this._widgetSelectorListeners.delete(surveyId);
+                SURVEY_LOGGER.info(`Removed click listener for survey ${surveyId}`);
+            }
+        };
+        this._removeWidgetSelectorListener = (survey)=>{
+            if (this._isWidgetSurveyOpen(survey)) return;
+            this._removeSurveyFromDom(survey);
+            this._detachWidgetSelectorListener(survey.id);
+        };
+        this._removeTabWidget = (survey)=>{
+            if (this._isWidgetSurveyOpen(survey)) return;
+            this._removeSurveyFromDom(survey);
+            this._renderedTabWidgets.delete(survey.id);
+        };
+        this._isWidgetSurveyOpen = (survey)=>{
+            try {
+                const shadowContainer = document.querySelector(getSurveyContainerClass(survey, true));
+                return !!shadowContainer?.shadowRoot?.querySelector('.ph-survey');
+            } catch  {
+                return false;
+            }
+        };
+        this._manageWidgetSelectorListener = (survey, selector)=>{
+            const currentElement = document.querySelector(selector);
+            const existingListenerData = this._widgetSelectorListeners.get(survey.id);
+            if (!currentElement) {
+                if (existingListenerData) this._removeWidgetSelectorListener(survey);
+                return;
+            }
+            this._handleWidget(survey);
+            if (existingListenerData) if (currentElement === existingListenerData.element) return;
+            else {
+                SURVEY_LOGGER.info(`Selector element changed for survey ${survey.id}. Re-attaching listener.`);
+                this._detachWidgetSelectorListener(survey.id);
+            }
+            if (!currentElement.hasAttribute(WIDGET_LISTENER_ATTRIBUTE)) {
+                const listener = (event)=>{
+                    event.stopPropagation();
+                    const positionStyles = survey.appearance?.position === SurveyPosition.NextToTrigger ? getNextToTriggerPosition(event.currentTarget, parseInt(survey.appearance?.maxWidth || defaultSurveyAppearance.maxWidth)) : {};
+                    window.dispatchEvent(new CustomEvent(DISPATCH_FEEDBACK_WIDGET_EVENT, {
+                        detail: {
+                            surveyId: survey.id,
+                            position: positionStyles
+                        }
+                    }));
+                };
+                addEventListener(currentElement, 'click', listener);
+                currentElement.setAttribute(WIDGET_LISTENER_ATTRIBUTE, 'true');
+                this._widgetSelectorListeners.set(survey.id, {
+                    element: currentElement,
+                    listener,
+                    survey
+                });
+                SURVEY_LOGGER.info(`Attached click listener for feedback button survey ${survey.id}`);
+            }
+        };
+        this.renderPopover = (survey)=>{
+            if (!this._host.client?.canCapture) return;
+            const { survey: translatedSurvey, language: surveyLanguage } = this._translateSurveyForRendering(survey);
+            const { shadow } = retrieveSurveyShadow(translatedSurvey, this._host);
+            this._renderedTargets.set(shadow, shadow.host);
+            render(/*#__PURE__*/ jsx(SurveyPopup, {
+                posthog: this._host,
+                survey: translatedSurvey,
+                removeSurveyFromFocus: this._removeSurveyFromFocus,
+                surveyLanguage: surveyLanguage
+            }), shadow);
+        };
+        this.renderSurvey = (survey, selector, properties)=>{
+            if (!this._host.client?.canCapture) return;
+            const { survey: translatedSurvey, language: surveyLanguage } = this._translateSurveyForRendering(survey);
+            let isSurveyCompleted = false;
+            if (this._host.config.prefillFromUrl) isSurveyCompleted = this._handleUrlPrefill(translatedSurvey, surveyLanguage, properties);
+            render(/*#__PURE__*/ jsx(SurveyPopup, {
+                posthog: this._host,
+                survey: translatedSurvey,
+                removeSurveyFromFocus: this._removeSurveyFromFocus,
+                isPopup: false,
+                properties: properties,
+                isSurveyCompleted: isSurveyCompleted,
+                surveyLanguage: surveyLanguage
+            }), selector);
+        };
+        this.getActiveMatchingSurveys = (callback, forceReload = false)=>{
+            this._host.surveys?.getSurveys((surveys)=>{
+                const targetingMatchedSurveys = surveys.filter((survey)=>this._shouldDisplaySurvey(survey));
+                callback(targetingMatchedSurveys);
+            }, forceReload);
+        };
+        this.callSurveysAndEvaluateDisplayLogic = (forceReload = false)=>{
+            this.getActiveMatchingSurveys((surveys)=>{
+                const canCaptureResponse = this._host.client?.canCapture;
+                const inAppSurveysWithDisplayLogic = surveys.filter((survey)=>canCaptureResponse && (survey.type === SurveyType.Popover || survey.type === SurveyType.Widget));
+                const matchingIds = new Set(inAppSurveysWithDisplayLogic.map((survey)=>survey.id));
+                for (const pendingSurveyId of Array.from(this._surveyTimeouts.keys()))if (!matchingIds.has(pendingSurveyId)) this.cancelSurvey(pendingSurveyId);
+                const inAppSurveysQueue = this._sortSurveysByAppearanceDelay(inAppSurveysWithDisplayLogic);
+                const activeSelectorSurveys = new Set();
+                const activeTabWidgetSurveys = new Set();
+                inAppSurveysQueue.forEach((survey)=>{
+                    if (survey.type === SurveyType.Widget) {
+                        if (survey.appearance?.widgetType === SurveyWidgetType.Tab) {
+                            activeTabWidgetSurveys.add(survey.id);
+                            this._handleWidget(survey);
+                            return;
+                        }
+                        if (survey.appearance?.widgetType === SurveyWidgetType.Selector && survey.appearance?.widgetSelector) {
+                            activeSelectorSurveys.add(survey.id);
+                            this._manageWidgetSelectorListener(survey, survey.appearance?.widgetSelector);
+                        }
+                    }
+                    if (isNull(this._surveyInFocus) && survey.type === SurveyType.Popover) this.handlePopoverSurvey(survey, void 0, {
+                        resumeDelayFromActivation: true
+                    });
+                });
+                this._widgetSelectorListeners.forEach(({ survey })=>{
+                    if (!activeSelectorSurveys.has(survey.id)) this._removeWidgetSelectorListener(survey);
+                });
+                this._renderedTabWidgets.forEach((tabSurvey, surveyId)=>{
+                    if (!activeTabWidgetSurveys.has(surveyId)) this._removeTabWidget(tabSurvey);
+                });
+            }, forceReload);
+        };
+        this._addSurveyToFocus = (survey)=>{
+            if (!isNull(this._surveyInFocus)) SURVEY_LOGGER.error(`Survey ${this._surveyInFocus} already in focus. Cannot add survey ${survey.id}.`);
+            this._surveyInFocus = survey.id;
+        };
+        this._removeSurveyFromFocus = (survey)=>{
+            if (this._surveyInFocus !== survey.id) SURVEY_LOGGER.error(`Survey ${survey.id} is not in focus. Cannot remove survey ${survey.id}.`);
+            this._clearSurveyTimeout(survey.id);
+            this._surveyInFocus = null;
+            this._currentLanguage = null;
+            this._surveyIsRendered = false;
+            this._surveyPopupProps = null;
+            this._displayOptions = void 0;
+            this._removeSurveyFromDom(survey);
+        };
+        this._host = posthog;
+        this._surveyInFocus = null;
+        this._languageChangeListener = ()=>this._onLanguageChange();
+        addEventListener(window, 'languagechange', this._languageChangeListener);
+        this._unsubscribeFeatureFlags = posthog.client?.getExtension(FeatureFlagsCommonExtension)?.onFeatureFlags(()=>this._onLanguageChange()) ?? null;
+    }
+    _onLanguageChange() {
+        if (isNull(this._surveyInFocus)) return;
+        const surveys = this._host.client?.kv.get(SURVEYS);
+        const survey = surveys?.find((s)=>s.id === this._surveyInFocus);
+        if (!survey) return;
+        const { survey: translatedSurvey, language: newLanguage } = this._translateSurveyForRendering(survey);
+        if (newLanguage === this._currentLanguage) return;
+        this._currentLanguage = newLanguage;
+        if (!this._surveyIsRendered) return;
+        const overriddenSurvey = this._applyDisplayOverrides(translatedSurvey, this._displayOptions);
+        const { shadow } = retrieveSurveyShadow(overriddenSurvey, this._host);
+        render(/*#__PURE__*/ jsx(SurveyPopup, {
+            ...this._surveyPopupProps,
+            posthog: this._host,
+            survey: overriddenSurvey,
+            removeSurveyFromFocus: this._removeSurveyFromFocus,
+            surveyLanguage: newLanguage
+        }), shadow);
+    }
+    _applyDisplayOverrides(survey, options) {
+        return options?.position || options?.selector ? {
+            ...survey,
+            appearance: {
+                ...survey.appearance,
+                ...options.position && {
+                    position: options.position
+                },
+                ...options.selector && {
+                    widgetSelector: options.selector
+                }
+            }
+        } : survey;
+    }
+    _clearSurveyTimeout(surveyId) {
+        const timeout = this._surveyTimeouts.get(surveyId);
+        if (timeout) {
+            clearTimeout(timeout);
+            this._surveyTimeouts.delete(surveyId);
+        }
+    }
+    cancelSurvey(surveyId) {
+        if (!this._surveyTimeouts.has(surveyId)) return;
+        SURVEY_LOGGER.info(`Cancelled pending survey ${surveyId}`);
+        this._clearSurveyTimeout(surveyId);
+        if (this._surveyInFocus === surveyId) {
+            this._surveyInFocus = null;
+            this._currentLanguage = null;
+            this._surveyIsRendered = false;
+            this._surveyPopupProps = null;
+            this._displayOptions = void 0;
+        }
+    }
+    startAutomaticDisplay() {
+        if (this._disposed || this._automaticDisplayDispose || false === this._host.config.automaticDisplay) return;
+        this._automaticDisplayDispose = ()=>{};
+        const dispose = startAutomaticDisplay(this);
+        if (this._disposed) dispose();
+        else this._automaticDisplayDispose = dispose;
+    }
+    clearInMemoryInProgressSurveyState() {
+        clearAllInMemoryInProgressSurveyState();
+    }
+    dispose() {
+        this._disposed = true;
+        this._automaticDisplayDispose?.();
+        this._automaticDisplayDispose = void 0;
+        if (this._languageChangeListener) {
+            window.removeEventListener('languagechange', this._languageChangeListener);
+            this._languageChangeListener = null;
+        }
+        if (this._unsubscribeFeatureFlags) {
+            this._unsubscribeFeatureFlags();
+            this._unsubscribeFeatureFlags = null;
+        }
+        this._surveyTimeouts.forEach((_timeout, surveyId)=>this._clearSurveyTimeout(surveyId));
+        this._widgetSelectorListeners.forEach((_listener, surveyId)=>this._detachWidgetSelectorListener(surveyId));
+        this._renderedTargets.forEach((container, target)=>{
+            render(null, target);
+            container?.remove();
+        });
+        this._renderedTargets.clear();
+        this._renderedTabWidgets.clear();
+        this._surveyInFocus = null;
+    }
+    _sortSurveysByAppearanceDelay(surveys) {
+        return surveys.sort((a, b)=>{
+            const isSurveyInProgressA = isSurveyInProgress(a);
+            const isSurveyInProgressB = isSurveyInProgress(b);
+            if (isSurveyInProgressA && !isSurveyInProgressB) return -1;
+            if (!isSurveyInProgressA && isSurveyInProgressB) return 1;
+            const aIsAlways = a.schedule === SurveySchedule.Always;
+            const bIsAlways = b.schedule === SurveySchedule.Always;
+            if (aIsAlways && !bIsAlways) return 1;
+            if (!aIsAlways && bIsAlways) return -1;
+            return (a.appearance?.surveyPopupDelaySeconds || 0) - (b.appearance?.surveyPopupDelaySeconds || 0);
+        });
+    }
+    _translateSurveyForRendering(survey) {
+        return applySurveyTranslationForUser(survey, this._host);
+    }
+    _handleUrlPrefill(survey, surveyLanguage, properties) {
+        if (this._prefillHandledSurveys.has(survey.id)) return false;
+        const { params } = extractPrefillParamsFromUrl(window.location.search);
+        if (0 === Object.keys(params).length) return false;
+        SURVEY_LOGGER.info('[Survey Prefill] Detected URL prefill parameters');
+        const result = this._processPrefillData(survey, params, surveyLanguage);
+        if (!result) return false;
+        this._autoSubmitPrefilledResponses(survey, result, properties, surveyLanguage);
+        this._prefillHandledSurveys.add(survey.id);
+        return result.isSurveyCompleted;
+    }
+    _autoSubmitPrefilledResponses(survey, result, properties, surveyLanguage) {
+        const { responses, submissionId, isSurveyCompleted, skippedResponses } = result;
+        const shouldAutoSubmitPrefilled = Object.keys(skippedResponses).length > 0 && survey.enable_partial_responses;
+        if (shouldAutoSubmitPrefilled || isSurveyCompleted) sendSurveyEvent({
+            responses: isSurveyCompleted ? responses : skippedResponses,
+            survey,
+            surveySubmissionId: submissionId,
+            posthog: this._host,
+            isSurveyCompleted,
+            properties,
+            surveyLanguage
+        });
+    }
+    _handleInitialResponses(survey, initialResponses, properties, surveyLanguage) {
+        const prefillParams = {};
+        for (const [indexStr, value] of Object.entries(initialResponses)){
+            const index = parseInt(indexStr);
+            prefillParams[index] = isArray(value) ? value.map(String) : [
+                String(value)
+            ];
+        }
+        SURVEY_LOGGER.info('[Survey] Processing initial responses');
+        const result = this._processPrefillData(survey, prefillParams, surveyLanguage);
+        if (!result) return false;
+        this._autoSubmitPrefilledResponses(survey, result, properties, surveyLanguage);
+        return result.isSurveyCompleted;
+    }
+    _processPrefillData(survey, prefillParams, surveyLanguage) {
+        try {
+            const responses = convertPrefillToResponses(survey, prefillParams);
+            if (0 === Object.keys(responses).length) {
+                SURVEY_LOGGER.warn('[Survey Prefill] No valid responses after conversion');
+                return null;
+            }
+            const submissionId = uuidv7();
+            const prefilledIndices = Object.keys(prefillParams).map((k)=>parseInt(k, 10));
+            const { startQuestionIndex, skippedResponses, skippedIndices } = calculatePrefillStartIndex(survey, prefilledIndices, responses);
+            const isSurveyCompleted = startQuestionIndex >= survey.questions.length;
+            setInProgressSurveyState(survey, {
+                surveySubmissionId: submissionId,
+                responses: responses,
+                lastQuestionIndex: startQuestionIndex,
+                questionOrder: getQuestionOrder(survey.questions),
+                visitedIndices: skippedIndices,
+                surveyLanguage
+            });
+            SURVEY_LOGGER.info('[Survey Prefill] Stored prefilled responses in localStorage');
+            return {
+                responses,
+                submissionId,
+                startQuestionIndex,
+                isSurveyCompleted,
+                skippedResponses
+            };
+        } catch (error) {
+            SURVEY_LOGGER.error('[Survey Prefill] Error handling prefill:', error);
+            return null;
+        }
+    }
+    _isSurveyFeatureFlagEnabled(flagKey, flagVariant) {
+        if (!flagKey) return true;
+        const featureFlags = this._host.client?.getExtension(FeatureFlagsCommonExtension);
+        const isFeatureEnabled = !!featureFlags?.isFeatureEnabled(flagKey, {
+            send_event: !flagKey.startsWith(SURVEY_TARGETING_FLAG_PREFIX)
+        });
+        let flagVariantCheck = true;
+        if (flagVariant) {
+            const flagVariantValue = featureFlags?.getFeatureFlag(flagKey, {
+                send_event: false
+            });
+            flagVariantCheck = flagVariantValue === flagVariant || 'any' === flagVariant;
+        }
+        const enabled = isFeatureEnabled && flagVariantCheck;
+        if (!enabled) this._warnIfFeatureFlagsDisabled(flagKey);
+        return enabled;
+    }
+    _warnIfFeatureFlagsDisabled(flagKey) {
+        if (this._loggedFeatureFlagsDisabledWarning || false !== this._host.config.featureFlagEvaluation) return;
+        this._loggedFeatureFlagsDisabledWarning = true;
+        SURVEY_LOGGER.warn(`Survey feature flag "${flagKey}" evaluated to false because advanced_disable_feature_flags is set. PostHog creates an internal targeting flag for almost every survey, so no survey can display while flags are disabled. To keep surveys working, replace advanced_disable_feature_flags with advanced_only_evaluate_survey_feature_flags, which evaluates survey flags only.`);
+    }
+    _isSurveyConditionMatched(survey) {
+        if (!survey.conditions) return true;
+        return doesSurveyUrlMatch(survey, this._host) && doesSurveyDeviceTypesMatch(survey) && doesSurveyMatchSelector(survey);
+    }
+    _internalFlagCheckSatisfied(survey) {
+        if (canActivateRepeatedly(survey)) return {
+            satisfied: true
+        };
+        if (survey.internal_targeting_flag_key && isSurveyIterationBased(survey) && !this._host.client?.getExtension(FeatureFlagsCommonExtension)?.hasLoadedFlags) {
+            this._warnIfFeatureFlagsDisabled(survey.internal_targeting_flag_key);
+            return {
+                satisfied: false,
+                reason: 'Feature flags have not loaded yet; deferring internal targeting flag check'
+            };
+        }
+        return {
+            satisfied: this._isSurveyFeatureFlagEnabled(survey.internal_targeting_flag_key)
+        };
+    }
+    checkSurveyEligibility(survey) {
+        const eligibility = {
+            eligible: true,
+            reason: void 0
+        };
+        if (!isSurveyRunning(survey)) {
+            eligibility.eligible = false;
+            eligibility.reason = `Survey is not running. It was completed on ${survey.end_date}`;
+            return eligibility;
+        }
+        if (!IN_APP_SURVEY_TYPES.includes(survey.type)) {
+            eligibility.eligible = false;
+            eligibility.reason = `Surveys of type ${survey.type} are never eligible to be shown in the app`;
+            return eligibility;
+        }
+        const linkedFlagVariant = survey.conditions?.linkedFlagVariant;
+        if (!this._isSurveyFeatureFlagEnabled(survey.linked_flag_key, linkedFlagVariant)) {
+            eligibility.eligible = false;
+            if (linkedFlagVariant) eligibility.reason = `Survey linked feature flag is not enabled for variant ${linkedFlagVariant}`;
+            else eligibility.reason = "Survey linked feature flag is not enabled";
+            return eligibility;
+        }
+        if (!this._isSurveyFeatureFlagEnabled(survey.targeting_flag_key)) {
+            eligibility.eligible = false;
+            eligibility.reason = "Survey targeting feature flag is not enabled";
+            return eligibility;
+        }
+        const internalFlagCheck = this._internalFlagCheckSatisfied(survey);
+        if (!internalFlagCheck.satisfied) {
+            eligibility.eligible = false;
+            eligibility.reason = internalFlagCheck.reason ?? 'Survey internal targeting flag is not enabled and survey cannot activate repeatedly and survey is not in progress';
+            return eligibility;
+        }
+        if (!hasWaitPeriodPassed(survey.conditions?.seenSurveyWaitPeriodInDays)) {
+            eligibility.eligible = false;
+            eligibility.reason = "Survey wait period has not passed";
+            return eligibility;
+        }
+        if (getSurveySeen(survey)) {
+            eligibility.eligible = false;
+            eligibility.reason = "Survey has already been seen and it can't be activated again";
+        }
+        return eligibility;
+    }
+    checkSurveyCaptureEligibility() {
+        if (!this._host.client?.canCapture) return {
+            eligible: false,
+            reason: SURVEY_CAPTURING_DISABLED
+        };
+        return {
+            eligible: true
+        };
+    }
+    checkSurveyDisplayEligibility(survey) {
+        const captureEligibility = this.checkSurveyCaptureEligibility();
+        if (!captureEligibility.eligible) return captureEligibility;
+        return this.checkSurveyEligibility(survey);
+    }
+    checkSurveyRenderability(survey) {
+        const eligibility = this.checkSurveyDisplayEligibility(survey);
+        if (eligibility.eligible && !this._hasActionOrEventTriggeredSurvey(survey)) return {
+            eligible: false,
+            reason: "Survey event/action trigger has not been fired yet"
+        };
+        return eligibility;
+    }
+    _hasActionOrEventTriggeredSurvey(survey) {
+        if (!doesSurveyActivateByEvent(survey) && !doesSurveyActivateByAction(survey)) return true;
+        const surveysActivatedByEventsOrActions = this._host.surveys?._surveyEventReceiver?.getSurveys();
+        return !!surveysActivatedByEventsOrActions?.includes(survey.id);
+    }
+    _checkFlags(survey) {
+        if (!survey.feature_flag_keys?.length) return true;
+        return survey.feature_flag_keys.every(({ key, value })=>{
+            if (!key || !value) return true;
+            return this._isSurveyFeatureFlagEnabled(value);
+        });
+    }
+    _shouldDisplaySurvey(survey) {
+        return this.checkSurveyEligibility(survey).eligible && this._isSurveyConditionMatched(survey) && this._hasActionOrEventTriggeredSurvey(survey) && this._checkFlags(survey);
+    }
+    _removeSurveyFromDom(survey) {
+        try {
+            const shadowContainer = document.querySelector(getSurveyContainerClass(survey, true));
+            if (shadowContainer?.shadowRoot) {
+                render(null, shadowContainer.shadowRoot);
+                this._renderedTargets.delete(shadowContainer.shadowRoot);
+            }
+            shadowContainer?.remove();
+        } catch (error) {
+            SURVEY_LOGGER.warn(`Failed to remove survey ${survey.id} from DOM:`, error);
+        }
+    }
+    getTestAPI() {
+        return {
+            addSurveyToFocus: this._addSurveyToFocus,
+            removeSurveyFromFocus: this._removeSurveyFromFocus,
+            surveyInFocus: this._surveyInFocus,
+            surveyTimeouts: this._surveyTimeouts,
+            handleWidget: this._handleWidget,
+            handlePopoverSurvey: this.handlePopoverSurvey,
+            manageWidgetSelectorListener: this._manageWidgetSelectorListener,
+            sortSurveysByAppearanceDelay: this._sortSurveysByAppearanceDelay.bind(this),
+            checkFlags: this._checkFlags.bind(this),
+            isSurveyFeatureFlagEnabled: this._isSurveyFeatureFlagEnabled.bind(this),
+            onLanguageChange: this._onLanguageChange.bind(this),
+            currentLanguage: this._currentLanguage,
+            surveyIsRendered: this._surveyIsRendered
+        };
+    }
+}
+const DEFAULT_PREVIEW_POSITION_STYLES = {
+    position: 'relative',
+    left: 'unset',
+    right: 'unset',
+    top: 'unset',
+    bottom: 'unset',
+    transform: 'unset'
+};
+const renderSurveysPreview = ({ survey, parentElement, previewPageIndex, forceDisableHtml, onPreviewSubmit, onPreviewBack, posthog, positionStyles = DEFAULT_PREVIEW_POSITION_STYLES })=>{
+    const currentStyle = parentElement.querySelector('style[data-ph-survey-style]');
+    if (currentStyle) currentStyle.remove();
+    const stylesheet = getSurveyStylesheet();
+    if (stylesheet) {
+        parentElement.appendChild(stylesheet);
+        addSurveyCSSVariablesToElement(parentElement, survey.type, survey.appearance);
+    }
+    render(/*#__PURE__*/ jsx(SurveyPopup, {
+        survey: survey,
+        posthog: posthog,
+        forceDisableHtml: forceDisableHtml,
+        style: positionStyles,
+        onPreviewSubmit: onPreviewSubmit,
+        onPreviewBack: onPreviewBack,
+        previewPageIndex: previewPageIndex,
+        removeSurveyFromFocus: ()=>{}
+    }), parentElement);
+};
+const renderFeedbackWidgetPreview = ({ survey, root, forceDisableHtml, posthog })=>{
+    const stylesheet = getSurveyStylesheet();
+    if (stylesheet) {
+        root.appendChild(stylesheet);
+        addSurveyCSSVariablesToElement(root, survey.type, survey.appearance);
+    }
+    render(/*#__PURE__*/ jsx(FeedbackWidget, {
+        forceDisableHtml: forceDisableHtml,
+        survey: survey,
+        posthog: posthog,
+        readOnly: true
+    }), root);
+};
+function generateSurveys(posthog, isSurveysEnabled) {
+    if ("u" < typeof document || "u" < typeof window) return;
+    const surveyManager = new SurveyManager(posthog);
+    if (false === posthog.config.automaticDisplay) {
+        SURVEY_LOGGER.info('Surveys automatic display is disabled. Skipping call surveys and evaluate display logic.');
+        return surveyManager;
+    }
+    if (false === isSurveysEnabled) {
+        SURVEY_LOGGER.info('There are no surveys to load or Surveys is disabled in the project settings.');
+        return surveyManager;
+    }
+    surveyManager.startAutomaticDisplay();
+    return surveyManager;
+}
+function startAutomaticDisplay(surveyManager) {
+    surveyManager.callSurveysAndEvaluateDisplayLogic(true);
+    let intervalId;
+    const startInterval = ()=>{
+        if (!isUndefined(intervalId)) return;
+        intervalId = setInterval(()=>{
+            surveyManager.callSurveysAndEvaluateDisplayLogic(false);
+        }, 1000);
+    };
+    const stopInterval = ()=>{
+        if (!isUndefined(intervalId)) {
+            clearInterval(intervalId);
+            intervalId = void 0;
+        }
+    };
+    startInterval();
+    const onVisibilityChange = ()=>{
+        if (document.hidden) stopInterval();
+        else {
+            surveyManager.callSurveysAndEvaluateDisplayLogic(false);
+            startInterval();
+        }
+    };
+    addEventListener(document, 'visibilitychange', onVisibilityChange);
+    return ()=>{
+        stopInterval();
+        document.removeEventListener('visibilitychange', onVisibilityChange);
+    };
+}
+function useHideSurveyOnURLChange({ survey, removeSurveyFromFocus = ()=>{}, setSurveyVisible, isPreviewMode = false, posthog }) {
+    useEffect(()=>{
+        if (isPreviewMode || !survey.conditions?.url) return;
+        const checkUrlMatch = ()=>{
+            const isSurveyTypeWidget = survey.type === SurveyType.Widget;
+            const doesSurveyMatchUrlCondition = doesSurveyUrlMatch(survey, posthog);
+            const isSurveyWidgetTypeTab = survey.appearance?.widgetType === SurveyWidgetType.Tab && isSurveyTypeWidget;
+            if (doesSurveyMatchUrlCondition) {
+                if (isSurveyWidgetTypeTab) {
+                    SURVEY_LOGGER.info(`Showing survey ${survey.id} because it is a feedback button tab and URL matches`);
+                    setSurveyVisible(true);
+                }
+                return;
+            }
+            SURVEY_LOGGER.info(`Hiding survey ${survey.id} because URL does not match`);
+            setSurveyVisible(false);
+            return removeSurveyFromFocus(survey);
+        };
+        addEventListener(window, 'popstate', checkUrlMatch);
+        addEventListener(window, 'hashchange', checkUrlMatch);
+        const originalPushState = window.history.pushState;
+        const originalReplaceState = window.history.replaceState;
+        window.history.pushState = function(...args) {
+            originalPushState.apply(this, args);
+            checkUrlMatch();
+        };
+        window.history.replaceState = function(...args) {
+            originalReplaceState.apply(this, args);
+            checkUrlMatch();
+        };
+        return ()=>{
+            window.removeEventListener('popstate', checkUrlMatch);
+            window.removeEventListener('hashchange', checkUrlMatch);
+            window.history.pushState = originalPushState;
+            window.history.replaceState = originalReplaceState;
+        };
+    }, [
+        isPreviewMode,
+        survey,
+        removeSurveyFromFocus,
+        setSurveyVisible,
+        posthog
+    ]);
+}
+const CLOSE_ANIMATION_DURATION_MS = 200;
+function usePopupVisibility(survey, posthog, millisecondDelay, isPreviewMode, removeSurveyFromFocus, isPopup, surveyContainerRef, skipShownEvent, surveyLanguage) {
+    const [isPopupVisible, setIsPopupVisible] = useState(isPreviewMode || 0 === millisecondDelay || survey.type === SurveyType.ExternalSurvey);
+    const [isSurveySent, setIsSurveySent] = useState(false);
+    const isClosingRef = useRef(false);
+    const hidePopupWithAnimation = ()=>{
+        const removeDOMAndHidePopup = ()=>{
+            if (isPopup) removeSurveyFromFocus(survey);
+            setIsPopupVisible(false);
+        };
+        if (isClosingRef.current) return;
+        const container = surveyContainerRef?.current;
+        if (!container) return void removeDOMAndHidePopup();
+        isClosingRef.current = true;
+        container.style.transition = `opacity ${CLOSE_ANIMATION_DURATION_MS}ms ease-out`;
+        container.style.opacity = '0';
+        setTimeout(()=>{
+            isClosingRef.current = false;
+            removeDOMAndHidePopup();
+        }, CLOSE_ANIMATION_DURATION_MS + 50);
+    };
+    const handleSurveyClosed = (event)=>{
+        if (event.detail.surveyId !== survey.id) return;
+        hidePopupWithAnimation();
+    };
+    useEffect(()=>{
+        if (!posthog) return void SURVEY_LOGGER.error('usePopupVisibility hook called without a PostHog instance.');
+        if (isPreviewMode) return;
+        let autoDisappearTimeout;
+        const handleSurveySent = (event)=>{
+            if (event.detail.surveyId !== survey.id) return;
+            if (!survey.appearance?.displayThankYouMessage) return hidePopupWithAnimation();
+            setIsSurveySent(true);
+            if (survey.appearance?.autoDisappear) {
+                if (autoDisappearTimeout) clearTimeout(autoDisappearTimeout);
+                autoDisappearTimeout = setTimeout(hidePopupWithAnimation, 5000);
+            }
+        };
+        const showSurvey = ()=>{
+            if (!doesSurveyUrlMatch(survey, posthog)) return;
+            setIsPopupVisible(true);
+            try {
+                localStorage.setItem('lastSeenSurveyDate', new Date().toISOString());
+            } catch  {}
+            window.dispatchEvent(new Event('PHSurveyShown'));
+            if (!skipShownEvent) posthog.client?.capture(SurveyEventName.SHOWN, {
+                [SurveyEventProperties.SURVEY_NAME]: survey.name,
+                [SurveyEventProperties.SURVEY_ID]: survey.id,
+                [SurveyEventProperties.SURVEY_ITERATION]: survey.current_iteration,
+                [SurveyEventProperties.SURVEY_ITERATION_START_DATE]: survey.current_iteration_start_date,
+                ...surveyLanguage && {
+                    [SurveyEventProperties.SURVEY_LANGUAGE]: surveyLanguage
+                },
+                sessionRecordingUrl: getSurveyReplayUrl(posthog)
+            });
+        };
+        addEventListener(window, 'PHSurveyClosed', handleSurveyClosed);
+        addEventListener(window, 'PHSurveySent', handleSurveySent);
+        const showTimeout = millisecondDelay > 0 ? setTimeout(showSurvey, millisecondDelay) : void 0;
+        if (isUndefined(showTimeout)) showSurvey();
+        return ()=>{
+            if (!isUndefined(showTimeout)) clearTimeout(showTimeout);
+            if (!isUndefined(autoDisappearTimeout)) clearTimeout(autoDisappearTimeout);
+            window.removeEventListener('PHSurveyClosed', handleSurveyClosed);
+            window.removeEventListener('PHSurveySent', handleSurveySent);
+        };
+    }, []);
+    useHideSurveyOnURLChange({
+        survey,
+        removeSurveyFromFocus,
+        setSurveyVisible: setIsPopupVisible,
+        isPreviewMode,
+        posthog
+    });
+    return {
+        isPopupVisible,
+        isSurveySent,
+        setIsPopupVisible,
+        hidePopupWithAnimation
+    };
+}
+function getTabPositionStyles(position = SurveyTabPosition.Right) {
+    switch(position){
+        case SurveyTabPosition.Top:
+            return {
+                top: '0',
+                left: '50%',
+                transform: 'translateX(-50%)'
+            };
+        case SurveyTabPosition.Left:
+            return {
+                top: '50%',
+                left: '0',
+                transform: 'rotate(90deg) translateY(-100%)',
+                transformOrigin: 'left top'
+            };
+        case SurveyTabPosition.Bottom:
+            return {
+                bottom: '0',
+                left: '50%',
+                transform: 'translateX(-50%)'
+            };
+        default:
+        case SurveyTabPosition.Right:
+            return {
+                top: '50%',
+                right: '0',
+                transform: 'rotate(-90deg) translateY(-100%)',
+                transformOrigin: 'right top'
+            };
+    }
+}
+function SurveyPopup({ survey, forceDisableHtml, posthog, style = {}, previewPageIndex, removeSurveyFromFocus = ()=>{}, isPopup = true, onPreviewSubmit = ()=>{}, onPreviewBack = ()=>{}, onPopupSurveyDismissed = ()=>{}, onCloseConfirmationMessage = ()=>{}, properties, isSurveyCompleted, skipShownEvent, surveyLanguage }) {
+    const surveyContainerRef = useRef(null);
+    const isPreviewMode = Number.isInteger(previewPageIndex);
+    const surveyPopupDelayMilliseconds = survey.appearance?.surveyPopupDelaySeconds ? 1000 * survey.appearance.surveyPopupDelaySeconds : 0;
+    const { isPopupVisible, isSurveySent, hidePopupWithAnimation } = usePopupVisibility(survey, posthog, surveyPopupDelayMilliseconds, isPreviewMode, removeSurveyFromFocus, isPopup, surveyContainerRef, skipShownEvent, surveyLanguage);
+    const shouldShowConfirmation = isSurveySent || previewPageIndex === survey.questions.length || true === isSurveyCompleted;
+    const [introScreenDismissed, setIntroScreenDismissed] = useState(false);
+    const hasInProgressState = useMemo(()=>!!getInProgressSurveyState(survey), [
+        survey
+    ]);
+    const hasIntroContent = !!(survey.appearance?.introScreenHeader || survey.appearance?.introScreenDescription);
+    const shouldShowIntroScreen = isPreviewMode ? previewPageIndex === INTRO_SCREEN_PREVIEW_INDEX : !!survey.appearance?.displayIntroScreen && hasIntroContent && !introScreenDismissed && !hasInProgressState;
+    const surveyContextValue = useMemo(()=>{
+        const getInProgressSurvey = getInProgressSurveyState(survey);
+        const surveySubmissionId = getInProgressSurvey?.surveySubmissionId || uuidv7() || '';
+        return {
+            isPreviewMode,
+            previewPageIndex: previewPageIndex,
+            onPopupSurveyDismissed: ()=>{
+                surveyLanguage ? dismissedSurveyEvent(survey, posthog, isPreviewMode, surveyLanguage) : dismissedSurveyEvent(survey, posthog, isPreviewMode);
+                onPopupSurveyDismissed();
+            },
+            isPopup: isPopup || false,
+            surveySubmissionId,
+            onPreviewSubmit,
+            onPreviewBack,
+            posthog,
+            properties,
+            surveyLanguage
+        };
+    }, [
+        isPreviewMode,
+        previewPageIndex,
+        isPopup,
+        posthog,
+        survey,
+        onPopupSurveyDismissed,
+        onPreviewSubmit,
+        onPreviewBack,
+        properties,
+        surveyLanguage
+    ]);
+    if (!isPopupVisible) return null;
+    return /*#__PURE__*/ jsx(SurveyContext.Provider, {
+        value: surveyContextValue,
+        children: /*#__PURE__*/ jsx("div", {
+            className: "ph-survey",
+            style: {
+                ...getPopoverPosition(survey.type, survey.appearance?.position, survey.appearance?.widgetType),
+                ...style
+            },
+            ref: surveyContainerRef,
+            children: shouldShowConfirmation ? /*#__PURE__*/ jsx(ConfirmationMessage, {
+                header: survey.appearance?.thankYouMessageHeader || 'Thank you!',
+                description: survey.appearance?.thankYouMessageDescription || '',
+                forceDisableHtml: !!forceDisableHtml,
+                contentType: survey.appearance?.thankYouMessageDescriptionContentType,
+                appearance: survey.appearance || defaultSurveyAppearance,
+                onClose: ()=>{
+                    hidePopupWithAnimation();
+                    onCloseConfirmationMessage();
+                }
+            }) : shouldShowIntroScreen ? /*#__PURE__*/ jsx(IntroScreen, {
+                header: survey.appearance?.introScreenHeader || '',
+                description: survey.appearance?.introScreenDescription || '',
+                forceDisableHtml: !!forceDisableHtml,
+                contentType: survey.appearance?.introScreenDescriptionContentType,
+                appearance: survey.appearance || defaultSurveyAppearance,
+                onStart: ()=>setIntroScreenDismissed(true)
+            }) : /*#__PURE__*/ jsx(Questions, {
+                survey: survey,
+                forceDisableHtml: !!forceDisableHtml,
+                posthog: posthog
+            })
+        })
+    });
+}
+function Questions({ survey, forceDisableHtml, posthog }) {
+    const initialInProgressState = useMemo(()=>{
+        const state = getInProgressSurveyState(survey);
+        if (!state) return null;
+        const hasIndex = isNumber(state.lastQuestionIndex);
+        const isIndexInRange = hasIndex && state.lastQuestionIndex >= 0 && state.lastQuestionIndex < survey.questions.length;
+        if (hasIndex && !isIndexInRange) {
+            clearInProgressSurveyState(survey);
+            return null;
+        }
+        return state;
+    }, [
+        survey
+    ]);
+    const [questionsResponses, setQuestionsResponses] = useState(()=>{
+        if (initialInProgressState?.responses) SURVEY_LOGGER.info('Survey is already in progress, filling in initial responses');
+        return initialInProgressState?.responses || {};
+    });
+    const [submissionBlocked, setSubmissionBlocked] = useState(false);
+    const { previewPageIndex, onPopupSurveyDismissed, isPopup, onPreviewSubmit, onPreviewBack, surveySubmissionId, isPreviewMode, properties, surveyLanguage } = useContext(SurveyContext);
+    const [currentQuestionIndex, setCurrentQuestionIndex] = useState(()=>{
+        const savedIndex = initialInProgressState?.lastQuestionIndex;
+        const validSavedIndex = isNumber(savedIndex) && savedIndex >= 0 && savedIndex < survey.questions.length ? savedIndex : 0;
+        return isNumber(previewPageIndex) && previewPageIndex >= 0 ? previewPageIndex : validSavedIndex;
+    });
+    const [visitedIndices, setVisitedIndices] = useState(()=>(initialInProgressState?.visitedIndices ?? []).filter((index)=>index >= 0 && index < survey.questions.length));
+    const [questionSnapshots, setQuestionSnapshots] = useState(()=>{
+        const inProgressSurveyData = getInProgressSurveyState(survey);
+        return inProgressSurveyData?.questionSnapshots ?? {};
+    });
+    const questionOrderIds = useMemo(()=>getQuestionOrder(getDisplayOrderQuestions(survey, initialInProgressState)), [
+        survey.id,
+        initialInProgressState
+    ]);
+    const surveyQuestions = useMemo(()=>{
+        const hasUsableIds = !!questionOrderIds && new Set(questionOrderIds).size === questionOrderIds.length;
+        if (!hasUsableIds) return getDisplayOrderQuestions(survey, initialInProgressState);
+        const byId = new Map(survey.questions.map((question)=>[
+                question.id,
+                question
+            ]));
+        const mapped = questionOrderIds.map((id)=>byId.get(id)).filter((question)=>!!question);
+        return mapped.length === questionOrderIds.length ? mapped : survey.questions;
+    }, [
+        questionOrderIds,
+        survey.questions,
+        survey,
+        initialInProgressState
+    ]);
+    useEffect(()=>{
+        if (isPreviewMode && !isUndefined(previewPageIndex) && previewPageIndex >= 0) setCurrentQuestionIndex(previewPageIndex);
+    }, [
+        previewPageIndex,
+        isPreviewMode
+    ]);
+    const onNextButtonClick = ({ res, displayQuestionIndex, questionId })=>{
+        if (!posthog) return void SURVEY_LOGGER.error('onNextButtonClick called without a PostHog instance.');
+        if (!posthog.client?.canCapture) return void setSubmissionBlocked(true);
+        setSubmissionBlocked(false);
+        if (!questionId) return void SURVEY_LOGGER.error('onNextButtonClick called without a questionId.');
+        const { responses: newResponses, questionSnapshots: newSnapshots } = recordSurveyAnswer({
+            responses: questionsResponses,
+            questionSnapshots
+        }, questionId, res, surveyQuestions[displayQuestionIndex]);
+        setQuestionsResponses(newResponses);
+        setQuestionSnapshots(newSnapshots);
+        const nextStep = getNextSurveyStep(survey, displayQuestionIndex, res);
+        const isSurveyCompleted = nextStep === SurveyQuestionBranchingType.End;
+        const newVisitedIndices = [
+            ...visitedIndices,
+            displayQuestionIndex
+        ];
+        if (!isSurveyCompleted) {
+            setVisitedIndices(newVisitedIndices);
+            setCurrentQuestionIndex(nextStep);
+            setInProgressSurveyState(survey, {
+                surveySubmissionId: surveySubmissionId,
+                responses: newResponses,
+                lastQuestionIndex: nextStep,
+                questionOrder: getQuestionOrder(surveyQuestions),
+                visitedIndices: newVisitedIndices,
+                surveyLanguage,
+                questionSnapshots: newSnapshots
+            });
+        }
+        if (survey.enable_partial_responses || isSurveyCompleted) {
+            const visitedResponseKeys = new Set(newVisitedIndices.map((i)=>surveyQuestions[i]?.id).filter((id)=>!!id).map((id)=>getSurveyResponseKey(id)));
+            const responsesOnPath = Object.fromEntries(Object.entries(newResponses).filter(([key])=>visitedResponseKeys.has(key)));
+            sendSurveyEvent({
+                responses: responsesOnPath,
+                survey,
+                surveySubmissionId,
+                isSurveyCompleted,
+                posthog,
+                properties,
+                surveyLanguage,
+                questionSnapshots: newSnapshots
+            });
+        }
+    };
+    const onBackButtonClick = ()=>{
+        if (isPreviewMode) return void onPreviewBack();
+        if (0 === visitedIndices.length) return;
+        const previousIndex = visitedIndices[visitedIndices.length - 1];
+        const newVisitedIndices = visitedIndices.slice(0, -1);
+        setVisitedIndices(newVisitedIndices);
+        setCurrentQuestionIndex(previousIndex);
+        setInProgressSurveyState(survey, {
+            surveySubmissionId,
+            responses: questionsResponses,
+            lastQuestionIndex: previousIndex,
+            questionOrder: getQuestionOrder(surveyQuestions),
+            visitedIndices: newVisitedIndices,
+            surveyLanguage,
+            questionSnapshots
+        });
+    };
+    const canGoBack = !!survey.appearance?.allowGoBack && (isPreviewMode ? (previewPageIndex ?? 0) > 0 : visitedIndices.length > 0);
+    const currentQuestion = surveyQuestions.at(currentQuestionIndex);
+    if (!currentQuestion) return null;
+    const renderCancelButton = isPopup && survey.appearance?.hideCancelButton !== true;
+    return /*#__PURE__*/ jsxs("form", {
+        className: "survey-form",
+        name: "surveyForm",
+        children: [
+            renderCancelButton && /*#__PURE__*/ jsx(Cancel, {
+                onClick: ()=>{
+                    onPopupSurveyDismissed();
+                }
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "survey-box",
+                "data-question-index": currentQuestionIndex,
+                children: [
+                    submissionBlocked && /*#__PURE__*/ jsx("p", {
+                        role: "alert",
+                        children: "Your response could not be sent. Please try again later."
+                    }),
+                    getQuestionComponent({
+                        question: currentQuestion,
+                        forceDisableHtml,
+                        displayQuestionIndex: currentQuestionIndex,
+                        appearance: survey.appearance || defaultSurveyAppearance,
+                        onSubmit: (res)=>onNextButtonClick({
+                                res,
+                                displayQuestionIndex: currentQuestionIndex,
+                                questionId: currentQuestion.id
+                            }),
+                        onPreviewSubmit,
+                        initialValue: currentQuestion.id ? questionsResponses[getSurveyResponseKey(currentQuestion.id)] : void 0,
+                        canGoBack,
+                        onBack: onBackButtonClick
+                    })
+                ]
+            })
+        ]
+    });
+}
+function FeedbackWidget({ survey, forceDisableHtml, posthog, readOnly, surveyLanguage }) {
+    const [isFeedbackButtonVisible, setIsFeedbackButtonVisible] = useState(true);
+    const [showSurvey, setShowSurvey] = useState(false);
+    const [styleOverrides, setStyleOverrides] = useState({});
+    const resetTimeout = useRef(void 0);
+    const toggleSurvey = ()=>{
+        if (!showSurvey && posthog && !readOnly && !posthog.client?.canCapture) return;
+        setShowSurvey(!showSurvey);
+    };
+    useEffect(()=>{
+        if (!posthog) return void SURVEY_LOGGER.error('FeedbackWidget called without a PostHog instance.');
+        if (readOnly) return;
+        if (survey.appearance?.widgetType === 'tab') setStyleOverrides({
+            top: '50%',
+            bottom: 'auto'
+        });
+        const handleShowSurvey = (event)=>{
+            const customEvent = event;
+            if (customEvent.detail?.surveyId === survey.id) {
+                SURVEY_LOGGER.info(`Received show event for feedback button survey ${survey.id}`);
+                setStyleOverrides(customEvent.detail.position || {});
+                toggleSurvey();
+            }
+        };
+        addEventListener(window, DISPATCH_FEEDBACK_WIDGET_EVENT, handleShowSurvey);
+        return ()=>{
+            if (!isUndefined(resetTimeout.current)) {
+                clearTimeout(resetTimeout.current);
+                resetTimeout.current = void 0;
+            }
+            window.removeEventListener(DISPATCH_FEEDBACK_WIDGET_EVENT, handleShowSurvey);
+        };
+    }, [
+        posthog,
+        readOnly,
+        survey.id,
+        survey.appearance?.widgetType,
+        survey.appearance?.widgetSelector,
+        survey.appearance?.borderColor
+    ]);
+    useHideSurveyOnURLChange({
+        survey,
+        setSurveyVisible: setIsFeedbackButtonVisible,
+        posthog
+    });
+    if (!isFeedbackButtonVisible) return null;
+    const resetShowSurvey = ()=>{
+        if (survey.schedule !== SurveySchedule.Always) setIsFeedbackButtonVisible(false);
+        if (!isUndefined(resetTimeout.current)) clearTimeout(resetTimeout.current);
+        resetTimeout.current = setTimeout(()=>{
+            resetTimeout.current = void 0;
+            setShowSurvey(false);
+        }, 200);
+    };
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            survey.appearance?.widgetType === 'tab' && /*#__PURE__*/ jsx("button", {
+                className: `ph-survey-widget-tab ${survey.appearance?.tabPosition === SurveyTabPosition.Top ? 'widget-tab-top' : ''}`,
+                onClick: toggleSurvey,
+                disabled: readOnly,
+                style: getTabPositionStyles(survey.appearance?.tabPosition),
+                children: survey.appearance?.widgetLabel || ''
+            }),
+            showSurvey && /*#__PURE__*/ jsx(SurveyPopup, {
+                posthog: posthog,
+                survey: survey,
+                forceDisableHtml: forceDisableHtml,
+                style: styleOverrides,
+                onPopupSurveyDismissed: resetShowSurvey,
+                onCloseConfirmationMessage: resetShowSurvey,
+                surveyLanguage: surveyLanguage
+            })
+        ]
+    });
+}
+const getQuestionComponent = ({ question, forceDisableHtml, displayQuestionIndex, appearance, onSubmit, onPreviewSubmit, initialValue, canGoBack, onBack })=>{
+    const baseProps = {
+        forceDisableHtml,
+        appearance,
+        onPreviewSubmit: (res)=>{
+            onPreviewSubmit(res);
+        },
+        onSubmit: (res)=>{
+            onSubmit(res);
+        },
+        initialValue,
+        displayQuestionIndex,
+        canGoBack,
+        onBack
+    };
+    switch(question.type){
+        case SurveyQuestionType.Open:
+            return /*#__PURE__*/ createElement(OpenTextQuestion, {
+                ...baseProps,
+                question: question,
+                key: question.id
+            });
+        case SurveyQuestionType.Link:
+            return /*#__PURE__*/ createElement(LinkQuestion, {
+                ...baseProps,
+                question: question,
+                key: question.id
+            });
+        case SurveyQuestionType.Rating:
+            return /*#__PURE__*/ createElement(RatingQuestion, {
+                ...baseProps,
+                question: question,
+                key: question.id
+            });
+        case SurveyQuestionType.SingleChoice:
+        case SurveyQuestionType.MultipleChoice:
+            return /*#__PURE__*/ createElement(MultipleChoiceQuestion, {
+                ...baseProps,
+                question: question,
+                key: question.id
+            });
+        default:
+            SURVEY_LOGGER.error(`Unsupported question type: ${question.type}`);
+            return null;
+    }
+};
+export { FeedbackWidget, INTRO_SCREEN_PREVIEW_INDEX, Questions, SurveyManager, SurveyPopup, generateSurveys, getNextSurveyStep, renderFeedbackWidgetPreview, renderSurveysPreview, useHideSurveyOnURLChange, usePopupVisibility };