@qualified-salesforce/web 0.0.1-oidc-bootstrap

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

@@ -0,0 +1,91 @@
+import { RenderedOffer } from "../rendering/RenderedOffer.js";
+
+
+class OfferManager {
+    get offers() {
+        return new Set(this.renderedOffers.values());
+    }
+    get isPaused() {
+        return this._isPaused;
+    }
+    subscribe(event, callback) {
+        this.subscribers[event].add(callback);
+        return ()=>{
+            this.subscribers[event].delete(callback);
+        };
+    }
+    pause() {
+        this.subscribers.beforePause.forEach((callback)=>callback());
+        this._isPaused = true;
+        this.subscribers.afterPause.forEach((callback)=>callback());
+    }
+    resume() {
+        this.subscribers.beforeResume.forEach((callback)=>callback());
+        this._isPaused = false;
+        this.subscribers.afterResume.forEach((callback)=>callback());
+    }
+    async add(offer, force) {
+        if (force === void 0) force = false;
+        if (this.isPaused && !force) {
+            return;
+        }
+        const currentOfferAtLocation = this.renderedOffers.get(offer.currentVersion.location);
+        if (currentOfferAtLocation && currentOfferAtLocation.position <= offer.position) {
+            return;
+        }
+        // Lock the location before async actions
+        const renderedOffer = RenderedOffer.create(offer);
+        this.renderedOffers.set(offer.currentVersion.location, renderedOffer);
+        if (currentOfferAtLocation) {
+            await this.remove(currentOfferAtLocation);
+        }
+        if (this.renderedOffers.get(offer.currentVersion.location) !== renderedOffer) {
+            // While waiting for the previous offer to be removed
+            // An offer was added at the same location but with a higher priority
+            return;
+        }
+        this.subscribers.beforeAdd.forEach((callback)=>callback(offer));
+        await renderedOffer.render({
+            animate: true
+        });
+        this.subscribers.afterAdd.forEach((callback)=>callback(renderedOffer));
+    }
+    async remove(renderedOffer) {
+        this.subscribers.beforeRemove.forEach((callback)=>callback(renderedOffer));
+        // Free up the location
+        if (this.renderedOffers.get(renderedOffer.location) === renderedOffer) {
+            this.renderedOffers.delete(renderedOffer.location);
+        }
+        await renderedOffer.remove({
+            animate: true
+        });
+        this.subscribers.afterRemove.forEach((callback)=>callback(renderedOffer));
+    }
+    async clear(param) {
+        let { except } = param;
+        this.subscribers.beforeClear.forEach((callback)=>callback());
+        const offersToRemove = [
+            ...this.renderedOffers.values()
+        ].filter((offer)=>!except.some((o)=>o.id === offer.serializedOffer.id));
+        await Promise.all(offersToRemove.map((offer)=>this.remove(offer)));
+        this.subscribers.afterClear.forEach((callback)=>callback());
+    }
+    constructor(){
+        this._isPaused = false;
+        this.renderedOffers = new Map();
+        this.subscribers = {
+            beforeAdd: new Set(),
+            afterAdd: new Set(),
+            beforeRemove: new Set(),
+            afterRemove: new Set(),
+            beforeClear: new Set(),
+            afterClear: new Set(),
+            beforePause: new Set(),
+            afterPause: new Set(),
+            beforeResume: new Set(),
+            afterResume: new Set()
+        };
+    }
+}
+
+export { OfferManager };

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

@@ -0,0 +1,125 @@
+import { __webpack_require__ } from "../../../../../js/runtime.js";
+import { DOMReady } from "../../../../../src/dom.js";
+import { _debugLog } from "../../../../../src/smart_website/utils.js";
+import { RenderingInitializer } from "../rendering/RenderingInitializer.js";
+import { isMobile } from "../utils.js";
+import { TargetTriggerTypeEnum } from "../../../../../src/graphql-types.js";
+import { queue } from "../../utils/promise-utils.js";
+import "../../../../../widget/utils/native_globals.js";
+
+/* provided dependency */ var TriggerManager_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var __nativeDocumentRemoveEventListener = __webpack_require__(68034).LA;
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+/* provided dependency */ var __nativeDocumentAddEventListener = __webpack_require__(68034).Qj;
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+
+
+
+
+
+
+const ON_EXIT_INTENT_WAIT_BEFORE_LISTENERS = 10000;
+const ON_EXIT_INTENT_SCROLL_SPEED_THRESHOLD = 160;
+class TriggerManager {
+    async trigger(offers) {
+        await Promise.all(offers.map((offer)=>this.triggerOffer(offer)));
+    }
+    clear() {
+        for (const handle of this.taskHandles.values()){
+            handle.cancel();
+        }
+        this.taskHandles.clear();
+    }
+    async triggerOffer(offer) {
+        const { trigger } = offer.currentVersion.target;
+        switch(trigger.type){
+            case TargetTriggerTypeEnum.AfterPageLoad:
+                await this.handleAfterPageLoad(offer, trigger);
+                break;
+            case TargetTriggerTypeEnum.OnExitIntent:
+                await this.handleOnExitIntent(offer);
+                break;
+            default:
+                this.debugLog("Unknown trigger type", {
+                    offer: JSON.stringify(offer)
+                });
+        }
+    }
+    async handleAfterPageLoad(offer, trigger) {
+        const handle = queue(()=>this.waitUntilLocationReady(offer), ()=>this.afterLoadPromise, ()=>new Promise((resolve)=>TriggerManager_setTimeout(resolve, trigger.delay * 1000)), ()=>this.context.manager.add(offer));
+        this.taskHandles.add(handle);
+        await handle.run();
+        this.taskHandles.delete(handle);
+    }
+    async handleOnExitIntent(offer) {
+        const handle = queue(()=>this.waitUntilLocationReady(offer), ()=>new Promise((resolve)=>TriggerManager_setTimeout(resolve, ON_EXIT_INTENT_WAIT_BEFORE_LISTENERS)), ()=>this.waitForExitIntent(), ()=>this.context.manager.add(offer));
+        this.taskHandles.add(handle);
+        await handle.run();
+        this.taskHandles.delete(handle);
+    }
+    async waitUntilLocationReady(offer) {
+        await RenderingInitializer.waitUntilLocationReady(offer.currentVersion.location);
+    }
+    async waitForExitIntent() {
+        if (this.mobile) {
+            await this.waitForMobileExitIntent();
+        } else {
+            await this.waitForDesktopExitIntent();
+        }
+    }
+    async waitForDesktopExitIntent() {
+        return new Promise((resolve)=>{
+            const handleMouseLeave = (event)=>{
+                if (event.clientY < 0) {
+                    resolve();
+                    document.documentElement.removeEventListener("mouseleave", handleMouseLeave);
+                }
+            };
+            document.documentElement.addEventListener("mouseleave", handleMouseLeave);
+        });
+    }
+    async waitForMobileExitIntent() {
+        return new Promise((resolve)=>{
+            const handleVisibilityChange = ()=>{
+                if (document.visibilityState !== "visible") {
+                    resolve();
+                    removeListeners();
+                }
+            };
+            let lastPosition = 0;
+            let newPosition = 0;
+            let currentSpeed = 0;
+            const scrollSpeed = ()=>{
+                lastPosition = window.scrollY;
+                TriggerManager_setTimeout(()=>{
+                    newPosition = window.scrollY;
+                }, 100);
+                currentSpeed = newPosition - lastPosition;
+                if (currentSpeed > ON_EXIT_INTENT_SCROLL_SPEED_THRESHOLD) {
+                    resolve();
+                    removeListeners();
+                }
+            };
+            const removeListeners = ()=>{
+                __nativeDocumentRemoveEventListener("visibilitychange", handleVisibilityChange);
+                __nativeWindowRemoveEventListener("scroll", scrollSpeed);
+            };
+            __nativeDocumentAddEventListener("visibilitychange", handleVisibilityChange);
+            __nativeWindowAddEventListener("scroll", scrollSpeed);
+        });
+    }
+    get mobile() {
+        return isMobile();
+    }
+    debugLog(msg, context) {
+        _debugLog("[offer-main-script] " + msg, context);
+    }
+    constructor(context){
+        this.context = context;
+        this.taskHandles = new Set();
+        this.afterLoadPromise = DOMReady();
+        this.context.manager.subscribe("beforeClear", ()=>this.clear());
+    }
+}
+
+export { TriggerManager };

package/routes/app/offers/scripts/rendering/ContentManager.js

@@ -0,0 +1,53 @@
+import { isHeadlineBodyButton, isHeadlineForm, isHeadlineButton, isHeadlineLink, isHeadlineBodyForm } from "../utils.js";
+import { ButtonBanner } from "./variations/ButtonBanner.js";
+import { ButtonModal } from "./variations/ButtonModal.js";
+import { FormBanner } from "./variations/FormBanner.js";
+import { FormModal } from "./variations/FormModal.js";
+import { LinkBanner } from "./variations/LinkBanner.js";
+
+
+
+
+
+
+
+class ContentManager {
+    insertContent(host, offer, state) {
+        const { content, location, foregroundImageConfig, foregroundImageUrl, backgroundImageConfig, backgroundImageUrl, backgroundType } = offer.currentVersion;
+        const props = (variation)=>({
+                id: offer.id,
+                variation,
+                foregroundImageConfig,
+                foregroundImageUrl,
+                backgroundImageConfig,
+                backgroundImageUrl,
+                backgroundType,
+                allowDismiss: content.dismissOptions.allowDismiss,
+                location,
+                privacyDisclosureText: offer.privacyDisclosureText,
+                formConfig: offer.currentVersion.qualifiedFormConfig,
+                privacyDisclosureId: offer.privacyDisclosureId
+            });
+        const { variation } = content;
+        if (isHeadlineButton(variation)) {
+            return ButtonBanner.withState(state)(props(variation), host, this.hasOffersFontEnhancements, this.hasDismissButtonAccessibilityEnabled);
+        } else if (isHeadlineLink(variation)) {
+            return LinkBanner.withState(state)(props(variation), host, this.hasOffersFontEnhancements, this.hasDismissButtonAccessibilityEnabled);
+        } else if (isHeadlineForm(variation)) {
+            return FormBanner.withState(state)(props(variation), host, this.hasOffersFontEnhancements, this.hasDismissButtonAccessibilityEnabled, this.hasOffersFormBannerMobileImprovements);
+        } else if (isHeadlineBodyButton(variation)) {
+            return ButtonModal.withState(state)(props(variation), host, this.hasOffersFontEnhancements, this.hasDismissButtonAccessibilityEnabled);
+        } else if (isHeadlineBodyForm(variation)) {
+            return FormModal.withState(state)(props(variation), host, this.hasOffersFontEnhancements, this.hasDismissButtonAccessibilityEnabled);
+        } else {
+            throw new Error("Unknown variation type: " + JSON.stringify(variation));
+        }
+    }
+    constructor(hasOffersFontEnhancements = false, hasDismissButtonAccessibilityEnabled = false, hasOffersFormBannerMobileImprovements = false){
+        this.hasOffersFontEnhancements = hasOffersFontEnhancements;
+        this.hasDismissButtonAccessibilityEnabled = hasDismissButtonAccessibilityEnabled;
+        this.hasOffersFormBannerMobileImprovements = hasOffersFormBannerMobileImprovements;
+    }
+}
+
+export { ContentManager };

package/routes/app/offers/scripts/rendering/LocationManager.js

@@ -0,0 +1,83 @@
+import { HOST_LOCATION_ATTRIBUTE } from "../constants.js";
+import { Footer } from "./locations/footer.js";
+import { Header } from "./locations/header/Header.js";
+import { Popup } from "./locations/popup.js";
+import { Sidebar } from "./locations/sidebar.js";
+import { LocationEnum } from "../../../../../src/graphql-types.js";
+
+/* eslint-disable rulesdir/enforce-comment */ /* eslint-disable rulesdir/css-units */ 
+
+
+
+
+
+class LocationManager {
+    createHost(offer, param) {
+        let { locationOverride = offer.currentVersion.location } = param === void 0 ? {} : param;
+        const host = this.getHandler(locationOverride).createHost(offer.id);
+        return this.addLocationAttribute(host, locationOverride);
+    }
+    insertHost(host) {
+        return this.getHandler(host).insertHost(host);
+    }
+    afterInsertAnimation(host) {
+        var _this_getHandler_afterInsertAnimation, _this_getHandler;
+        return (_this_getHandler_afterInsertAnimation = (_this_getHandler = this.getHandler(host)).afterInsertAnimation) == null ? void 0 : _this_getHandler_afterInsertAnimation.call(_this_getHandler, host);
+    }
+    beforeRemoveAnimation(host) {
+        var _this_getHandler_beforeRemoveAnimation, _this_getHandler;
+        return (_this_getHandler_beforeRemoveAnimation = (_this_getHandler = this.getHandler(host)).beforeRemoveAnimation) == null ? void 0 : _this_getHandler_beforeRemoveAnimation.call(_this_getHandler, host);
+    }
+    removeHost(host) {
+        return this.getHandler(host).removeHost(host);
+    }
+    addLocationAttribute(host, location) {
+        host.setAttribute(HOST_LOCATION_ATTRIBUTE, location);
+        return host;
+    }
+    getLocation(hostOrOffer) {
+        if (typeof hostOrOffer === "string") {
+            return hostOrOffer;
+        }
+        if (!(hostOrOffer instanceof HTMLElement)) {
+            return hostOrOffer.currentVersion.location;
+        }
+        const location = hostOrOffer.getAttribute(HOST_LOCATION_ATTRIBUTE);
+        if (!location) {
+            throw new Error("Host does not have a location");
+        }
+        return location;
+    }
+    getHandler(hostOrOffer) {
+        const location = this.getLocation(hostOrOffer);
+        const handler = this.LOCATIONS_HANDLERS.get(location);
+        if (!handler) {
+            throw new Error("Unknown location: " + location);
+        }
+        return handler;
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(flags = {}){
+        this.flags = flags;
+        this.LOCATIONS_HANDLERS = new Map([
+            [
+                LocationEnum.Footer,
+                new Footer()
+            ],
+            [
+                LocationEnum.Header,
+                new Header()
+            ],
+            [
+                LocationEnum.Popup,
+                new Popup(this.flags)
+            ],
+            [
+                LocationEnum.Sidebar,
+                new Sidebar()
+            ]
+        ]);
+    }
+}
+
+export { LocationManager };

package/routes/app/offers/scripts/rendering/RenderedOffer.js

@@ -0,0 +1,188 @@
+import { __webpack_require__ } from "../../../../../js/runtime.js";
+import { getDefaultQualifiedFormConfig } from "../../../websiteBuilder/stores/storeHelpers.js";
+import "../../../../../widget/utils/native_globals.js";
+import { _extends } from "../../../../../js/4101.js";
+import { CtaTypeEnum } from "../../../../../src/graphql-types.js";
+
+/* provided dependency */ var RenderedOffer_setTimeout = __webpack_require__(68034).pS;
+
+
+
+class RenderedOffer {
+    static setup(renderer) {
+        this.renderer = renderer;
+    }
+    static create(serializedOffer) {
+        if (this.renderer === null) {
+            throw new Error("Renderer is not set");
+        }
+        return new OnScreenOffer(serializedOffer);
+    }
+    get serializedOffer() {
+        return this._serializedOffer;
+    }
+    get offerId() {
+        return this.serializedOffer.id;
+    }
+    get versionId() {
+        return this.serializedOffer.currentVersion.id;
+    }
+    get position() {
+        return this.serializedOffer.position;
+    }
+    get location() {
+        return this.serializedOffer.currentVersion.location;
+    }
+    get ctaType() {
+        return this.serializedOffer.currentVersion.ctaType;
+    }
+    get variationType() {
+        return this.serializedOffer.currentVersion.content.variation.type;
+    }
+    get qualifiedFormConfig() {
+        var _this_serializedOffer_currentVersion_qualifiedFormConfig;
+        return (_this_serializedOffer_currentVersion_qualifiedFormConfig = this.serializedOffer.currentVersion.qualifiedFormConfig) != null ? _this_serializedOffer_currentVersion_qualifiedFormConfig : getDefaultQualifiedFormConfig();
+    }
+    get renderer() {
+        if (RenderedOffer.renderer === null) {
+            throw new Error("Renderer is not set");
+        }
+        return RenderedOffer.renderer;
+    }
+    async render(options) {
+        if (options === void 0) options = {};
+        if (this.isOnScreen() || this.isRendering) {
+            return;
+        }
+        if (this.isRemoving) {
+            throw new Error("Attempting to render an offer while it is being removed");
+        }
+        this.isRendering = true;
+        this._staticOffer = await this.renderer.render(this.serializedOffer, options);
+        this.isRendering = false;
+    }
+    async remove(options) {
+        if (options === void 0) options = {};
+        if (!this.isOnScreen() || this.isRemoving) {
+            return;
+        }
+        if (this.isRendering) {
+            throw new Error("Attempting to remove an offer while it is being rendered");
+        }
+        this.isRemoving = true;
+        await this.renderer.remove(this.serializedOffer, options);
+        this._staticOffer = null;
+        this.isRemoving = false;
+    }
+    async animate() {
+        if (this.isOnScreen()) {
+            await this.remove({
+                animate: true
+            });
+            await new Promise((resolve)=>RenderedOffer_setTimeout(resolve, 250));
+        }
+        await this.render({
+            animate: true
+        });
+    }
+    async update(newSerializedOffer, options) {
+        if (options === void 0) options = {};
+        if (newSerializedOffer.id !== this.serializedOffer.id) {
+            throw new Error("Cannot update with a different offer");
+        }
+        if (!this.isOnScreen()) {
+            this._serializedOffer = newSerializedOffer;
+            await this.render(options);
+            return;
+        }
+        const oldStaticOffer = this.staticOffer;
+        const state = options.copyState && this.ctaType === newSerializedOffer.currentVersion.ctaType ? this.staticOffer.state : undefined;
+        if (this.location !== newSerializedOffer.currentVersion.location) {
+            await this.remove(options);
+            this._serializedOffer = newSerializedOffer;
+            await this.render(_extends({}, options, {
+                state
+            }));
+        } else {
+            this._serializedOffer = newSerializedOffer;
+            this._staticOffer = this.renderer.update(this._serializedOffer, state);
+        }
+        if (options.copyListeners) {
+            this.staticOffer.copyListeners(oldStaticOffer);
+        }
+    }
+    isOnScreen() {
+        return this._staticOffer !== null;
+    }
+    isForm() {
+        return this.isOnScreen() && this.ctaType === CtaTypeEnum.Form;
+    }
+    isButton() {
+        return this.isOnScreen() && this.ctaType !== CtaTypeEnum.Form;
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(serializedOffer){
+        this._staticOffer = null;
+        this.isRendering = false;
+        this.renderingPromise = null;
+        this.isRemoving = false;
+        this.removingPromise = null;
+        this._serializedOffer = serializedOffer;
+    }
+}
+RenderedOffer.renderer = null;
+// Private class
+class OnScreenOffer extends RenderedOffer {
+    get staticOffer() {
+        if (this._staticOffer === null) {
+            throw new Error("Offer is not on screen");
+        }
+        return this._staticOffer;
+    }
+    get staticOfferId() {
+        return this.staticOffer.id;
+    }
+    get state() {
+        return this.staticOffer.state;
+    }
+    dismiss() {
+        this.staticOffer.dismiss();
+    }
+    enableForm() {
+        this.staticOffer.enableForm();
+    }
+    disableForm() {
+        this.staticOffer.disableForm();
+    }
+    getEmailInputValue() {
+        return this.staticOffer.getEmailInputValue();
+    }
+    getEmailFormInput() {
+        return this.staticOffer.getEmailFormInput();
+    }
+    getPrivacyDisclosureTooltip() {
+        return this.staticOffer.getPrivacyDisclosureTooltip();
+    }
+    getFormValues() {
+        for(var _len = arguments.length, names = new Array(_len), _key = 0; _key < _len; _key++){
+            names[_key] = arguments[_key];
+        }
+        return this.staticOffer.getFormValues(...names);
+    }
+    constructor(...args){
+        var _this;
+        super(...args), _this = this, this.registerListeners = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            return _this.staticOffer.registerListeners(...args);
+        }, this.setState = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            return _this.staticOffer.setState(...args);
+        };
+    }
+}
+
+export { RenderedOffer };

package/routes/app/offers/scripts/rendering/Renderer.js

@@ -0,0 +1,69 @@
+import { _debugLog } from "../../../../../src/smart_website/utils.js";
+import { getHostId } from "../utils.js";
+import { AnimationManager } from "./animations/AnimationManager.js";
+import { ContentManager } from "./ContentManager.js";
+import { LocationManager } from "./LocationManager.js";
+
+
+
+
+
+
+class Renderer {
+    async render(offer, param) {
+        let { animate = false, state } = param === void 0 ? {} : param;
+        const host = this.locationManager.createHost(offer);
+        const renderedOffer = this.contentManager.insertContent(host, offer, state);
+        this.locationManager.insertHost(host);
+        if (animate) {
+            try {
+                await this.animationManager.getAnimator(host, offer.currentVersion.location, offer.currentVersion.content.animation).animate();
+            } catch (error) {
+                this.debugLog("Error animating offer: " + error, {
+                    offerId: offer.id,
+                    location: offer.currentVersion.location,
+                    animation: offer.currentVersion.content.animation.type
+                });
+            }
+        }
+        this.locationManager.afterInsertAnimation(host);
+        return renderedOffer;
+    }
+    /**
+   * Used to update the inner content of an offer without changing its location
+   */ update(offer, state) {
+        const host = document.getElementById(getHostId(offer.id));
+        if (!host) return;
+        return this.contentManager.insertContent(host, offer, state);
+    }
+    async remove(offer, param) {
+        let { animate = false } = param === void 0 ? {} : param;
+        const host = document.getElementById(getHostId(offer.id));
+        if (!host) return;
+        this.locationManager.beforeRemoveAnimation(host);
+        if (animate) {
+            try {
+                await this.animationManager.getAnimator(host, offer.currentVersion.location, offer.currentVersion.content.animation).reverse();
+            } catch (error) {
+                this.debugLog("Error animating offer: " + error, {
+                    offerId: offer.id,
+                    location: offer.currentVersion.location,
+                    animation: offer.currentVersion.content.animation.type
+                });
+            }
+        }
+        this.locationManager.removeHost(host);
+    }
+    debugLog(message, context) {
+        if (context === void 0) context = {};
+        _debugLog("[Renderer] " + message, context);
+    }
+    constructor(offerFeatureFlags = {}){
+        this.offerFeatureFlags = offerFeatureFlags;
+        this.locationManager = new LocationManager(offerFeatureFlags);
+        this.contentManager = new ContentManager(offerFeatureFlags.hasOffersFontEnhancements, offerFeatureFlags.hasDismissButtonAccessibilityEnabled, offerFeatureFlags.hasOffersFormBannerMobileImprovements);
+        this.animationManager = new AnimationManager();
+    }
+}
+
+export { Renderer };

package/routes/app/offers/scripts/rendering/RenderingInitializer.js

@@ -0,0 +1,62 @@
+import { Footer } from "./locations/footer.js";
+import { Header } from "./locations/header/Header.js";
+import { RenderedOffer } from "./RenderedOffer.js";
+import { Renderer } from "./Renderer.js";
+import { LocationEnum } from "../../../../../src/graphql-types.js";
+import { assertUnreachable } from "../../../../../components/shared/assertUnreachable.js";
+
+
+
+
+
+
+
+class RenderingInitializer {
+    static async waitUntilLocationReady(location) {
+        if (!this.isInitialized) {
+            throw new Error("RenderingInitializer not initialized");
+        }
+        if (!this.locationInitializationMap[location]) {
+            await this.initializeLocation(location);
+            this.locationInitializationMap[location] = true;
+        }
+    }
+    static init(param) {
+        let { offerFeatureFlags, offersHeaderConfig } = param;
+        if (this.isInitialized) return;
+        this.offerFeatureFlags = offerFeatureFlags;
+        this.offersHeaderConfig = offersHeaderConfig;
+        RenderedOffer.setup(new Renderer(offerFeatureFlags));
+        this.isInitialized = true;
+    }
+    static async initializeLocation(location) {
+        switch(location){
+            case LocationEnum.Header:
+                {
+                    await Header.setup(this.offersHeaderConfig);
+                    break;
+                }
+            case LocationEnum.Footer:
+                Footer.setup();
+                break;
+            case LocationEnum.Popup:
+                break;
+            case LocationEnum.Sidebar:
+                break;
+            case LocationEnum.Embed:
+                break;
+            default:
+                assertUnreachable(location);
+        }
+    }
+}
+RenderingInitializer.isInitialized = false;
+RenderingInitializer.locationInitializationMap = {
+    [LocationEnum.Header]: false,
+    [LocationEnum.Footer]: false,
+    [LocationEnum.Popup]: false,
+    [LocationEnum.Sidebar]: false,
+    [LocationEnum.Embed]: false
+};
+
+export { RenderingInitializer };