@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/routes/app/offers/scripts/OfferMainScript.js

@@ -0,0 +1,154 @@
+import { withCaptureExceptions, captureWidgetExceptions } from "../../../../widget/capture_widget_exceptions.js";
+import { default as WidgetObject } from "../../../../widget/widget_object.js";
+import { ButtonManager } from "./main/ButtonManager.js";
+import { FormManager } from "./main/FormManager.js";
+import { MainContext } from "./main/MainContext.js";
+import { OfferManager } from "./main/OfferManager.js";
+import { TriggerManager } from "./main/TriggerManager.js";
+import { RenderingInitializer } from "./rendering/RenderingInitializer.js";
+import { __decorate, __metadata } from "../../../../js/4101.js";
+
+
+
+
+
+
+
+
+
+
+
+class OfferMainScript extends WidgetObject {
+    get hasActiveForm() {
+        return this.formManager.hasActiveOffer;
+    }
+    pause() {
+        this.context.manager.pause();
+    }
+    resume() {
+        this.context.manager.resume();
+    }
+    get offerFeatureFlags() {
+        if (this._offerFeatureFlags) return this._offerFeatureFlags;
+        this._offerFeatureFlags = {
+            hasOffersFontEnhancements: this.config.hasOffersFontEnhancements,
+            disableQOfferInfo: this.config.disableQOfferInfo,
+            hasOffersPopupWithScrollDisabler: this.config.hasOffersPopupWithScrollDisabler,
+            hasWidgetFullScreenWithScrollDisabler: this.config.hasWidgetFullScreenWithScrollDisabler,
+            hasDismissButtonAccessibilityEnabled: this.config.hasDismissButtonAccessibilityEnabled,
+            hasOffersFormBannerMobileImprovements: this.config.hasOffersFormBannerMobileImprovements
+        };
+        return this._offerFeatureFlags;
+    }
+    async init(offers) {
+        const processedOffers = this.processOffers(offers);
+        if (this.context.manager.isPaused) {
+            this.pendingOffers = processedOffers;
+            return;
+        }
+        const keptOffers = this.offers.filter((offer)=>processedOffers.some((o)=>o.id === offer.id));
+        await this.clearOffers({
+            except: keptOffers
+        });
+        this.offers = processedOffers;
+        await this.triggerManager.trigger(this.offers.filter((offer)=>!keptOffers.some((o)=>o.id === offer.id)));
+    }
+    initPendingOffers() {
+        if (!this.pendingOffers) return;
+        // Must await, void, or catch to avoid swallowing errors. In this case, we can use void,
+        // because init already uses captureWidgetExceptions to catch errors
+        void this.init(this.pendingOffers);
+        this.pendingOffers = null;
+    }
+    async clearOffers(param) {
+        let { except } = param;
+        await this.context.manager.clear({
+            except
+        });
+        this.offers = [
+            ...except
+        ];
+    }
+    // Sort the offers by position and remove duplicate locations, keeping the lowest position for each location
+    processOffers(queuedOffers) {
+        // Sort the offers by position
+        let offers = [
+            ...queuedOffers
+        ].sort((a, b)=>a.position - b.position);
+        // Remove duplicate locations, keep lowest position for each location
+        const locations = new Set();
+        offers = offers.filter((offer)=>{
+            if (locations.has(offer.currentVersion.location)) return false;
+            locations.add(offer.currentVersion.location);
+            return true;
+        });
+        return offers;
+    }
+    constructor(injectionProps){
+        super(injectionProps), this.offers = [], this.pendingOffers = null, this._offerFeatureFlags = null;
+        // This is a shared entry point for managing and rendering offers.
+        // We use captureWidgetExceptions and withCaptureExceptions here to
+        // ensure errors raised in offers-related code are caught and logged.
+        const OfferManagerWithCaptureExceptions = withCaptureExceptions(OfferManager, this.widget, {
+            context: "Offers::OfferManager"
+        });
+        this.context = new MainContext(this.pageViewActivityEmitter, this.dateProvider, this.channel, new OfferManagerWithCaptureExceptions(), ()=>this.iframeManager);
+        const TriggerManagerWithCaptureExceptions = withCaptureExceptions(TriggerManager, this.widget, {
+            context: "Offers::TriggerManager"
+        });
+        const ButtonManagerWithCaptureExceptions = withCaptureExceptions(ButtonManager, this.widget, {
+            context: "Offers::ButtonManager"
+        });
+        const FormManagerWithCaptureExceptions = withCaptureExceptions(FormManager, this.widget, {
+            context: "Offers::FormManager"
+        });
+        this.triggerManager = new TriggerManagerWithCaptureExceptions(this.context);
+        this.buttonManager = new ButtonManagerWithCaptureExceptions(this.context, this.offerFeatureFlags);
+        this.formManager = new FormManagerWithCaptureExceptions(this.context);
+        this.context.manager.subscribe("afterResume", ()=>this.initPendingOffers());
+        RenderingInitializer.init({
+            offerFeatureFlags: this.offerFeatureFlags,
+            offersHeaderConfig: this.config.offersHeaderConfig
+        });
+        this.channel.on("initOffers", (offers)=>{
+            this.offerScript.init(offers).then(()=>{
+                // We only care about the first call to initOffers per widget instance
+                if (this.widget.widgetIdForInitOffers === this.widget.widgetId) return;
+                this.widget.logTiming("Offers load time", "offers_time_to_init_ms");
+                this.widget.widgetIdForInitOffers = this.widget.widgetId;
+            }).catch(()=>{
+            // NOOP, OfferMainScript#init already uses captureWidgetExceptions to report errors
+            });
+        });
+    }
+}
+__decorate([
+    captureWidgetExceptions({
+        context: "Offers::OfferMainScript#init"
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        typeof Immutable === "undefined" ? Object : Immutable
+    ]),
+    __metadata("design:returntype", Promise)
+], OfferMainScript.prototype, "init", null);
+__decorate([
+    captureWidgetExceptions({
+        context: "Offers::OfferMainScript#initPendingOffers"
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], OfferMainScript.prototype, "initPendingOffers", null);
+__decorate([
+    captureWidgetExceptions({
+        context: "Offers::OfferMainScript#clearOffers"
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        Object
+    ]),
+    __metadata("design:returntype", Promise)
+], OfferMainScript.prototype, "clearOffers", null);
+
+export { OfferMainScript };

package/routes/app/offers/scripts/constants.js

@@ -0,0 +1,71 @@
+import { LocationEnum } from "../../../../src/graphql-types.js";
+
+
+// See #q-messenger-frame in services/app/javascript/widget/widget.string.scss
+const Q_MESSENGER_FRAME_Z_INDEX = 2147483642;
+// Ensure offers do not block messenger or dismiss messenger button
+const DEFAULT_OFFERS_Z_INDEX = Q_MESSENGER_FRAME_Z_INDEX - 1;
+// Unlike other offer types, popups are meant be overlayed on top all website content
+const POPUP_OFFERS_Z_INDEX = Q_MESSENGER_FRAME_Z_INDEX + 1;
+const PRIVACY_DISCLOSURE_ARIA_LABEL_PREFIX = "Privacy disclosure text: ";
+const HOST_LOCATION_ATTRIBUTE = "data-qualified-offer-host-location";
+const ANIMATED_FIXED_ELEMENT_DATA_ATTRIBUTE = "data-qualified-offer-animated-fixed-element";
+// DO NOT CHANGE THIS VALUE, it is used externally
+const HEADER_HEIGHT_CSS_VARIABLE = "--qualified-offer-header-height";
+const HEADER_IGNORE_ELEMENT_DATA_ATTRIBUTE = "data-qualified-offer-header-ignore";
+const HEADER_INCLUDE_ELEMENT_DATA_ATTRIBUTE = "data-qualified-offer-header-include";
+// DO NOT CHANGE THIS VALUE, it is used externally
+const FOOTER_HEIGHT_CSS_VARIABLE = "--qualified-offer-footer-height";
+const RESIZE_THROTTLE_MS = 250;
+const MOBILE_THRESHOLD = 540;
+const MODAL_WIDTHS = {
+    desktop: {
+        [LocationEnum.Popup]: 450,
+        [LocationEnum.Sidebar]: 326
+    },
+    mobile: {
+        [LocationEnum.Popup]: 343,
+        [LocationEnum.Sidebar]: 326
+    }
+};
+const MODAL_PADDING = {
+    desktop: {
+        [LocationEnum.Popup]: "64px",
+        [LocationEnum.Sidebar]: "32px"
+    },
+    mobile: {
+        [LocationEnum.Popup]: "32px",
+        [LocationEnum.Sidebar]: "32px"
+    }
+};
+const MODAL_IMAGE_MAX_HEIGHTS = {
+    mobile: {
+        [LocationEnum.Popup]: "400px",
+        [LocationEnum.Sidebar]: "300px"
+    },
+    desktop: {
+        [LocationEnum.Popup]: "400px",
+        [LocationEnum.Sidebar]: "300px"
+    }
+};
+const MODAL_IMAGE_MAX_WIDTHS = {
+    mobile: {
+        [LocationEnum.Popup]: "400px",
+        [LocationEnum.Sidebar]: "300px"
+    },
+    desktop: {
+        [LocationEnum.Popup]: "500px",
+        [LocationEnum.Sidebar]: "400px"
+    }
+};
+// Scale uploaded images to this width
+const IMAGE_WIDTH_PX = 1000;
+const BANNER_HEIGHT = "52px";
+// Safety rails to ensure banner and banner content do not expand
+// and fill the entire screen
+const MAX_BANNER_HEIGHT = "200px";
+const MAX_BANNER_HEADLINE_HEIGHT = "180px";
+
+var constants_ANIMATED_FIXED_ELEMENT_DATA_ATTRIBUTE = /* unused export */ undefined;
+var constants_IMAGE_WIDTH_PX = /* unused export */ undefined;
+export { BANNER_HEIGHT, DEFAULT_OFFERS_Z_INDEX, FOOTER_HEIGHT_CSS_VARIABLE, HEADER_HEIGHT_CSS_VARIABLE, HEADER_IGNORE_ELEMENT_DATA_ATTRIBUTE, HEADER_INCLUDE_ELEMENT_DATA_ATTRIBUTE, HOST_LOCATION_ATTRIBUTE, MAX_BANNER_HEADLINE_HEIGHT, MAX_BANNER_HEIGHT, MOBILE_THRESHOLD, MODAL_IMAGE_MAX_HEIGHTS, MODAL_IMAGE_MAX_WIDTHS, MODAL_PADDING, MODAL_WIDTHS, POPUP_OFFERS_Z_INDEX, PRIVACY_DISCLOSURE_ARIA_LABEL_PREFIX, RESIZE_THROTTLE_MS, constants_ANIMATED_FIXED_ELEMENT_DATA_ATTRIBUTE as ANIMATED_FIXED_ELEMENT_DATA_ATTRIBUTE, constants_IMAGE_WIDTH_PX as IMAGE_WIDTH_PX };

package/routes/app/offers/scripts/main/ButtonManager.js

@@ -0,0 +1,65 @@
+import { toBase64 } from "../../../../../src/string.js";
+import { delay as timing_delay } from "../../../../../src/timing.js";
+
+
+
+class ButtonManager {
+    handle(offer) {
+        if (!offer.isButton()) return;
+        this.context.activityEmitter.emitOfferShown({
+            offerVersionId: offer.versionId
+        });
+        offer.registerListeners({
+            onDismissClick: ()=>this.handleOfferDismiss(offer),
+            onCtaClick: (e)=>this.handleOfferClick(offer, e)
+        });
+    }
+    async handleOfferDismiss(offer) {
+        await this.context.manager.remove(offer);
+        this.context.activityEmitter.emitOfferDismiss({
+            offerVersionId: offer.versionId
+        });
+    }
+    async handleOfferClick(offer, event) {
+        if (!event) return;
+        const anchor = event.currentTarget;
+        if (anchor.hasAttribute("data-is-acked")) {
+            await this.context.manager.remove(offer);
+            return;
+        }
+        // Prevent default behaviour and stop bubbling to allow tracking of the click event
+        event.preventDefault();
+        // Prevent the event from bubbling up to the parent element
+        event.stopImmediatePropagation();
+        // Mark the event as acked to prevent duplicate tracking
+        anchor.setAttribute("data-is-acked", "true");
+        // Disable pointer events to prevent the anchor from being clicked again
+        const originalPointerEvents = anchor.style.pointerEvents;
+        anchor.style.pointerEvents = "none";
+        // Track the click event
+        this.context.activityEmitter.emitOfferClick({
+            offerVersionId: offer.versionId
+        });
+        // Wait 100ms to make sure the click event is received by the server
+        await timing_delay(100);
+        // Restore pointer events
+        anchor.style.pointerEvents = originalPointerEvents;
+        const uri = new URL(anchor.href);
+        const expiration = this.context.dateProvider.now() + 60 * 1000; // expire in 1 minute
+        const offerInfo = toBase64(JSON.stringify({
+            id: offer.versionId,
+            expiration
+        }));
+        uri.searchParams.delete("q_offer_info");
+        if (!this.offerFeatureFlags.disableQOfferInfo) uri.searchParams.append("q_offer_info", offerInfo);
+        anchor.setAttribute("href", uri.toString());
+        anchor.click();
+    }
+    constructor(context, offerFeatureFlags){
+        this.context = context;
+        this.offerFeatureFlags = offerFeatureFlags;
+        context.manager.subscribe("afterAdd", (offer)=>this.handle(offer));
+    }
+}
+
+export { ButtonManager };

package/routes/app/offers/scripts/main/FormManager.js

@@ -0,0 +1,325 @@
+import { __webpack_require__ } from "../../../../../js/runtime.js";
+import { _debugLog } from "../../../../../src/smart_website/utils.js";
+import { QualifiedFormApi } from "../../../../../widget/qualified_form/qualified_form_api.js";
+import "../rendering/lib/FormComponent.js";
+import { toFollowupQuestionsOffer } from "../utils.js";
+import { LocationEnum } from "../../../../../src/graphql-types.js";
+import "../../../../../widget/utils/native_globals.js";
+
+/* provided dependency */ var FormManager_setTimeout = __webpack_require__(68034).pS;
+
+
+
+
+
+const LOCATIONS_WITH_FOLLOWUP_MODAL = [
+    LocationEnum.Header,
+    LocationEnum.Footer
+];
+// Modal disclosures are displayed when the form is rendered initially
+const LOCATIONS_WITH_DISCLOSURE_ON_RENDER = [
+    LocationEnum.Popup,
+    LocationEnum.Sidebar
+];
+// Banner disclosures are displayed within a tooltip when the form is focused
+const LOCATIONS_WITH_DISCLOSURE_ON_INPUT_FOCUS = [
+    LocationEnum.Header,
+    LocationEnum.Footer
+];
+class FormManager {
+    get hasActiveOffer() {
+        return this.activeOffer !== null;
+    }
+    handle(offer) {
+        if (!offer.isForm()) return;
+        this.context.activityEmitter.emitOfferShown({
+            offerVersionId: offer.versionId
+        });
+        this.registerListeners(offer);
+    }
+    registerListeners(offer) {
+        const handlePrivacyDisclosureShown = ()=>{
+            var _offer_serializedOffer;
+            return this.handlePrivacyDisclosureShown(offer, offer.versionId, (offer == null ? void 0 : (_offer_serializedOffer = offer.serializedOffer) == null ? void 0 : _offer_serializedOffer.privacyDisclosureId) || undefined);
+        };
+        if (LOCATIONS_WITH_DISCLOSURE_ON_RENDER.includes(offer.location)) {
+            handlePrivacyDisclosureShown();
+        }
+        offer.registerListeners({
+            onDismissClick: ()=>this.handleOfferDismiss(offer),
+            onFormSubmit: ()=>this.handleOfferSubmit(offer),
+            onPrivacyDisclosureShown: ()=>{
+                return LOCATIONS_WITH_DISCLOSURE_ON_INPUT_FOCUS.includes(offer.location) ? handlePrivacyDisclosureShown() : ()=>{};
+            }
+        });
+    }
+    async handleOfferDismiss(offer) {
+        var _this_activeOffer;
+        if (!this.activeOffer || !this.activeOffer.is(offer) || !this.activeOffer.isCompleted) {
+            this.context.activityEmitter.emitOfferDismiss({
+                offerVersionId: offer.versionId
+            });
+        }
+        if ((_this_activeOffer = this.activeOffer) == null ? void 0 : _this_activeOffer.is(offer)) {
+            this.resumeAllFormOffers();
+            this.activeOffer = null;
+        }
+        await this.context.manager.remove(offer);
+    }
+    async handleOfferSubmit(offer) {
+        var _this_activeOffer, _offer_serializedOffer;
+        // Handle close button click
+        if (((_this_activeOffer = this.activeOffer) == null ? void 0 : _this_activeOffer.state.current) === (/* inlined export .FormState.End */"end")) {
+            await this.handleOfferDismiss(offer);
+            return;
+        }
+        if (this.activeOffer && !this.activeOffer.is(offer)) {
+            this.debugLog("Cannot submit form while another form is in progress");
+            return;
+        }
+        if (!this.activeOffer) {
+            this.activeOffer = new ActiveOffer(offer, this.context);
+            this.pauseAllFormOffers();
+        }
+        await this.activeOffer.handleSubmission();
+        this.handlePrivacyDisclosureConsented(offer.versionId, (offer == null ? void 0 : (_offer_serializedOffer = offer.serializedOffer) == null ? void 0 : _offer_serializedOffer.privacyDisclosureId) || undefined);
+    }
+    handlePrivacyDisclosureShown(offer, offerVersionId, privacyDisclosureId) {
+        if (offerVersionId && privacyDisclosureId) {
+            if (this.offerVersionIdToShownPrivacyDisclosureId[offerVersionId]) return;
+            this.offerVersionIdToShownPrivacyDisclosureId[offerVersionId] = privacyDisclosureId;
+            this.context.activityEmitter.emitPrivacyDisclosureShown({
+                offerVersionId: offerVersionId,
+                privacyDisclosureId: privacyDisclosureId
+            });
+        }
+        // Accessibility callout: this allows us to programmatically focus the tooltip after pressing tab within email input.
+        // This ensures keyboard users can tab into the tooltip and access links within it.
+        if ((offer == null ? void 0 : offer.getEmailFormInput()) && (offer == null ? void 0 : offer.getPrivacyDisclosureTooltip())) {
+            const emailFormInput = offer.getEmailFormInput();
+            const privacyDisclosureTooltip = offer.getPrivacyDisclosureTooltip();
+            emailFormInput.tabIndex = 0;
+            privacyDisclosureTooltip.tabIndex = -1;
+            emailFormInput.addEventListener("keydown", (event)=>{
+                if (event.key === "Tab" && !event.shiftKey) {
+                    // Temporary fix display to "flex" and force tooltip to be visible, because you cannot focus on hidden elements
+                    privacyDisclosureTooltip.style.display = "flex";
+                    privacyDisclosureTooltip.focus();
+                    privacyDisclosureTooltip.style.display = "";
+                }
+            });
+        }
+    }
+    handlePrivacyDisclosureConsented(offerVersionId, privacyDisclosureId) {
+        if (offerVersionId && privacyDisclosureId) {
+            this.context.activityEmitter.emitPrivacyDisclosureConsented({
+                offerVersionId: offerVersionId,
+                privacyDisclosureId: privacyDisclosureId
+            });
+        }
+    }
+    pauseAllFormOffers() {
+        if (!this.activeOffer) return;
+        this.context.manager.pause();
+        for (const offer of this.context.manager.offers){
+            if (offer.isForm() && !this.activeOffer.is(offer)) {
+                offer.disableForm();
+            }
+        }
+    }
+    resumeAllFormOffers() {
+        for (const offer of this.context.manager.offers){
+            offer.isForm() && offer.enableForm();
+        }
+        this.context.manager.resume();
+    }
+    debugLog(msg, context) {
+        _debugLog("[form-manager] " + msg, context);
+    }
+    constructor(context){
+        this.context = context;
+        this.activeOffer = null;
+        this.offerVersionIdToShownPrivacyDisclosureId = {};
+        this.context.manager.subscribe("afterAdd", (offer)=>this.handle(offer));
+    }
+}
+class ActiveOffer {
+    get state() {
+        return this.offer.state;
+    }
+    get isCompleted() {
+        return this._isCompleted;
+    }
+    is(offer) {
+        return this.offer === offer;
+    }
+    async handleSubmission() {
+        if (this.state.loading || this.state.current === (/* inlined export .FormState.End */"end")) {
+            this.debugLog("Cannot submit form in state " + this.state);
+            return;
+        }
+        switch(this.state.current){
+            case (/* inlined export .FormState.EmailCapture */"emailCapture"):
+                await this.handleEmailSubmission();
+                break;
+            case (/* inlined export .FormState.FollowupQuestions */"followupQuestions"):
+                await this.handleFollowupQuestionsSubmission();
+                break;
+        }
+    }
+    async handleEmailSubmission() {
+        const email = this.offer.getEmailInputValue();
+        if (!email) {
+            this.offer.setState({
+                current: (/* inlined export .FormState.EmailCapture */"emailCapture"),
+                error: "Please enter a valid email"
+            });
+            return;
+        }
+        const response = this.qualifiedFormApi.submitEmail(email);
+        if (!response.success) {
+            let error;
+            switch(response.error){
+                case (/* inlined export .EmailError.EMPTY */"empty"):
+                case (/* inlined export .EmailError.INVALID */"invalid"):
+                    error = "Please enter a valid email.";
+                    break;
+                case (/* inlined export .EmailError.NON_BUSINESS */"non_business"):
+                    error = "Please provide a business email.";
+                    break;
+            }
+            this.offer.setState({
+                current: (/* inlined export .FormState.EmailCapture */"emailCapture"),
+                email,
+                error
+            });
+            return;
+        }
+        this.context.activityEmitter.emitOfferClick({
+            offerVersionId: this.offer.versionId
+        });
+        this.offer.setState({
+            current: (/* inlined export .FormState.EmailCapture */"emailCapture"),
+            email,
+            loading: true
+        });
+        const { form, action } = await response.result;
+        this.followupQuestionsForm = form;
+        if (!this.offer.isOnScreen()) {
+            // Offer was dismissed before the form was loaded
+            // We might want to track this metric in the future
+            if (!form) {
+                // No followup questions, so we can mark the offer as completed
+                this.markAsCompleted();
+            }
+            return;
+        }
+        // This is already handled by the backend
+        if (!form) {
+            this.markAsCompleted();
+            this.handleEndAction(await action);
+            return;
+        }
+        await this.transitionToFollowupQuestions();
+    }
+    async handleFollowupQuestionsSubmission() {
+        if (!this.followupQuestionsForm) return;
+        const entries = this.offer.getFormValues(...this.followupQuestionsForm.inputFields.map((field)=>field.name));
+        if (!entries) return;
+        const result = this.qualifiedFormApi.submitFollowUpQuestions(entries);
+        if (result.success) {
+            this.markAsCompleted();
+            this.offer.setState({
+                current: (/* inlined export .FormState.FollowupQuestions */"followupQuestions"),
+                email: this.offer.state.email,
+                loading: true
+            }, {
+                animate: true
+            });
+            const action = await result.action;
+            if (!this.offer.isOnScreen()) {
+                // Offer was dismissed before the action was received
+                return;
+            }
+            this.handleEndAction(action);
+            return;
+        }
+        this.offer.setState({
+            current: (/* inlined export .FormState.FollowupQuestions */"followupQuestions"),
+            email: this.offer.state.email,
+            errors: result.errors
+        }, {
+            animate: true
+        });
+    }
+    markAsCompleted() {
+        if (this._isCompleted) return;
+        this._isCompleted = true;
+        this.context.activityEmitter.emitFormFill({
+            formType: "offer",
+            offerVersionId: this.offer.versionId
+        });
+    }
+    handleEndAction(action) {
+        if (action.type === (/* inlined export .EndActionType.WIDGET */"widget")) {
+            this.offer.dismiss();
+        } else if (action.type === (/* inlined export .EndActionType.REDIRECT */"redirect") && action.url) {
+            window.location.href = action.url;
+        } else {
+            this.transitionToEnd({
+                dismiss: LOCATIONS_WITH_FOLLOWUP_MODAL.includes(this.offer.location)
+            });
+        }
+    }
+    transitionToEnd(param) {
+        let { dismiss = false } = param === void 0 ? {} : param;
+        if (dismiss) FormManager_setTimeout(()=>this.offer.dismiss(), 1000);
+        const state = {
+            current: (/* inlined export .FormState.End */"end"),
+            email: this.offer.state.email
+        };
+        const animatedLocations = [
+            LocationEnum.Popup,
+            LocationEnum.Sidebar
+        ];
+        const animate = animatedLocations.includes(this.offer.location);
+        this.offer.setState(state, {
+            animate
+        });
+    }
+    async transitionToFollowupQuestions() {
+        if (!this.followupQuestionsForm) return;
+        this.offer.setState({
+            current: (/* inlined export .FormState.FollowupQuestions */"followupQuestions"),
+            form: this.followupQuestionsForm,
+            email: this.offer.state.email
+        }, {
+            animate: !LOCATIONS_WITH_FOLLOWUP_MODAL.includes(this.offer.location)
+        });
+        if (LOCATIONS_WITH_FOLLOWUP_MODAL.includes(this.offer.location)) {
+            await this.offer.update(toFollowupQuestionsOffer(this.offer.serializedOffer), {
+                animate: true,
+                copyListeners: true,
+                copyState: true
+            });
+        }
+    }
+    debugLog(msg, context) {
+        _debugLog("[offer-main-script] " + msg, context);
+    }
+    constructor(offer, context){
+        this.offer = offer;
+        this.context = context;
+        this.followupQuestionsForm = null;
+        this._isCompleted = false;
+        this.qualifiedFormApi = new QualifiedFormApi({
+            source: (/* inlined export .QualifiedFormSource.OFFERS */"offers"),
+            config: offer.qualifiedFormConfig,
+            channel: this.context.channel,
+            iframeManager: this.context.iframeManager,
+            offerId: this.offer.serializedOffer.id
+        });
+    }
+}
+
+export { FormManager };

package/routes/app/offers/scripts/main/MainContext.js

@@ -0,0 +1,19 @@
+import { tryGet } from "../../../../../src/utils.js";
+
+
+class MainContext {
+    get iframeManager() {
+        var _tryGet;
+        return (_tryGet = tryGet(()=>this.getIframeManager())) != null ? _tryGet : null;
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(activityEmitter, dateProvider, channel, manager, getIframeManager){
+        this.activityEmitter = activityEmitter;
+        this.dateProvider = dateProvider;
+        this.channel = channel;
+        this.manager = manager;
+        this.getIframeManager = getIframeManager;
+    }
+}
+
+export { MainContext };