@flagship.io/js-sdk/dist/chunks/browser/esm/thfSquI5.js

Flagship JS SDK

import { F as FS_QA_ASSISTANT_SCRIPT_TAG_ID, Q as QA_ASSISTANT_LOCAL_URL, T as TAG_QA_URL, a as FS_QA_URL, b as FS_VARIATIONS_FORCED_UNALLOCATION, c as FS_VARIATIONS_FORCED_ALLOCATION, S as SDK_INFO, d as FS_FORCED_VARIATIONS, e as FS_IS_QA_MODE_ENABLED, i as isBrowser, l as logInfoSprintf, f as TRUSTED_QA_ORIGINS, g as QA_ASSISTANT_PROD_URL, o as onDomReady, h as QA_ASSISTANT_STAGING_URL, j as TAG_QA_ASSISTANT_LOCAL, k as FS_QA_ASSISTANT_LOCAL, m as TAG_QA_ASSISTANT_STAGING, n as FS_QA_ASSISTANT_STAGING, p as TAG_QA_ASSISTANT, q as FS_QA_ASSISTANT } from './CTepUjTU.js';
import { s as sendVisitorAllocatedVariations, a as sendVisitorExposedVariations, I as INTERNAL_EVENTS, M as MSG_NAME_FROM_IFRAME } from './VuR6QkrD.js';
import 'events';

const getScriptElement = (src) => document.querySelector(`script[src*="${src}"]`);
/**
 *
 * @param bundleFileUrl
 */
function appendScript(bundleFileUrl) {
    if (getScriptElement(TAG_QA_URL) || getScriptElement(FS_QA_URL)) {
        return;
    }
    const script = document.createElement('script');
    script.src = bundleFileUrl;
    script.id = FS_QA_ASSISTANT_SCRIPT_TAG_ID;
    if (bundleFileUrl === QA_ASSISTANT_LOCAL_URL) {
        script.crossOrigin = 'anonymous';
    }
    document.body.append(script);
}

function onQaAssistantReady(visitorVariationState) {
    if (visitorVariationState.visitorVariations) {
        sendVisitorAllocatedVariations(visitorVariationState);
    }
    if (visitorVariationState.exposedVariations) {
        sendVisitorExposedVariations(visitorVariationState);
    }
}
function render(forcedReFetchFlags = false) {
    if (SDK_INFO.name === 'TypeScript') {
        window.location.reload();
    }
    const triggerRenderEvent = new CustomEvent(INTERNAL_EVENTS.FsTriggerRendering, { detail: { forcedReFetchFlags } });
    window.dispatchEvent(triggerRenderEvent);
}
function onQaAssistantClose({ config, func, visitorVariationState }) {
    config.isQAModeEnabled = false;
    sessionStorage.removeItem(FS_IS_QA_MODE_ENABLED);
    if (func) {
        window.removeEventListener('message', func);
    }
    document.getElementById(FS_QA_ASSISTANT_SCRIPT_TAG_ID)?.remove();
    visitorVariationState.forcedVariations = {};
    render();
}
function onApplyForcedVariations({ value, visitorVariationState }) {
    const sessionForcedVariations = sessionStorage.getItem(FS_FORCED_VARIATIONS);
    let forcedVariations = {};
    try {
        forcedVariations = JSON.parse(sessionForcedVariations || '{}');
    }
    catch (error) {
        // eslint-disable-next-line no-console
        console.error('Error parsing sessionForcedVariations', error);
    }
    forcedVariations = {
        ...forcedVariations,
        ...value
    };
    sessionStorage.setItem(FS_FORCED_VARIATIONS, JSON.stringify(forcedVariations));
    visitorVariationState.forcedVariations = forcedVariations;
    render();
}
function onResetForcedVariations(visitorVariationState) {
    sessionStorage.removeItem(FS_FORCED_VARIATIONS);
    visitorVariationState.forcedVariations = {};
    render();
}
function removeForcedVariation(keys, visitorVariationState) {
    const sessionForcedVariations = sessionStorage.getItem(FS_FORCED_VARIATIONS);
    let forcedVariations = {};
    try {
        forcedVariations = JSON.parse(sessionForcedVariations || '{}');
    }
    catch (error) {
        // eslint-disable-next-line no-console
        console.error('Error parsing sessionForcedVariations', error);
    }
    keys.forEach((key) => {
        delete forcedVariations[key];
    });
    sessionStorage.setItem(FS_FORCED_VARIATIONS, JSON.stringify(forcedVariations));
    visitorVariationState.forcedVariations = forcedVariations;
}
function onRemoveForcedVariation({ keys, visitorVariationState }) {
    removeForcedVariation(keys, visitorVariationState);
    visitorVariationState.shouldForceRender = true;
    render(true);
}
function onVariationsForcedAllocation({ value, visitorVariationState }) {
    sessionStorage.setItem(FS_VARIATIONS_FORCED_ALLOCATION, JSON.stringify(value));
    const variationsForcedAllocation = visitorVariationState.variationsForcedAllocation || {};
    const diffVariationKeys = Object.keys(variationsForcedAllocation).filter((key) => !(key in value));
    if (diffVariationKeys.length > 0) {
        removeForcedVariation(diffVariationKeys, visitorVariationState);
    }
    visitorVariationState.variationsForcedAllocation = value;
    visitorVariationState.shouldForceRender = true;
    render(true);
}
function onVariationsForcedUnallocation({ value, visitorVariationState }) {
    sessionStorage.setItem(FS_VARIATIONS_FORCED_UNALLOCATION, JSON.stringify(value));
    visitorVariationState.variationsForcedUnallocation = value;
    visitorVariationState.shouldForceRender = true;
    render(true);
}

function handleIframeMessage({ event, config, func, visitorVariationState }) {
    if (!config.isQAModeEnabled || !isBrowser()) {
        return;
    }
    switch (event.data.name) {
        case MSG_NAME_FROM_IFRAME.FsQaAssistantReady:
            onQaAssistantReady(visitorVariationState);
            break;
        case MSG_NAME_FROM_IFRAME.MinimizeQaAssistantClose:
        case MSG_NAME_FROM_IFRAME.QaAssistantClose:
            onQaAssistantClose({
                config,
                func,
                visitorVariationState
            });
            break;
        case MSG_NAME_FROM_IFRAME.FsApplyForcedVariations:
            onApplyForcedVariations({
                value: event.data.value,
                visitorVariationState
            });
            break;
        case MSG_NAME_FROM_IFRAME.FsResetForcedVariations:
            onResetForcedVariations(visitorVariationState);
            break;
        case MSG_NAME_FROM_IFRAME.FsTriggerRender:
            render(true);
            break;
        case MSG_NAME_FROM_IFRAME.FsVariationsForcedAllocation:
            onVariationsForcedAllocation({
                value: event.data.value,
                visitorVariationState
            });
            break;
        case MSG_NAME_FROM_IFRAME.FsVariationsForcedUnallocation:
            onVariationsForcedUnallocation({
                value: event.data.value,
                visitorVariationState
            });
            break;
        case MSG_NAME_FROM_IFRAME.FsRemoveForcedVariation:
            onRemoveForcedVariation({
                keys: event.data.value,
                visitorVariationState
            });
            break;
    }
}

function loadSessionVariations(key) {
    const sessionData = sessionStorage.getItem(key);
    let variations = {};
    try {
        variations = JSON.parse(sessionData || '{}');
    }
    catch (error) {
        // eslint-disable-next-line no-console
        console.error(`Error parsing ${key}`, error);
    }
    return variations;
}
/**
 *
 * @param config
 * @returns
 */
function loadQaAssistant(config, bundleUrl = null, visitorVariationState) {
    if (!window?.frames?.ABTastyQaAssistant) {
        logInfoSprintf(config, 'QA assistant', 'Loading QA Assistant');
        appendScript(bundleUrl || QA_ASSISTANT_PROD_URL);
    }
    visitorVariationState.forcedVariations = loadSessionVariations(FS_FORCED_VARIATIONS);
    visitorVariationState.variationsForcedAllocation = loadSessionVariations(FS_VARIATIONS_FORCED_ALLOCATION);
    visitorVariationState.variationsForcedUnallocation = loadSessionVariations(FS_VARIATIONS_FORCED_UNALLOCATION);
    if (window.__flagshipSdkQaAssistantMessageHandler) {
        window.removeEventListener('message', window.__flagshipSdkQaAssistantMessageHandler);
    }
    const eventListenerMessage = (event) => {
        if (!TRUSTED_QA_ORIGINS.includes(event?.origin)) {
            return;
        }
        handleIframeMessage({
            visitorVariationState,
            event,
            config,
            func: eventListenerMessage
        });
    };
    window.__flagshipSdkQaAssistantMessageHandler = eventListenerMessage;
    window.addEventListener('message', window.__flagshipSdkQaAssistantMessageHandler);
    config.isQAModeEnabled = true;
    sessionStorage.setItem(FS_IS_QA_MODE_ENABLED, 'true');
}

/**
 *
 * @param config
 */
function listenForKeyboardQaAssistant(config, visitorVariationState) {
    logInfoSprintf(config, 'QA assistant', 'Listening for keyboard events to launch QA Assistant');
    if (window.__flagshipSdkOnKeyCombinationDown) {
        document.removeEventListener('keydown', window.__flagshipSdkOnKeyCombinationDown);
    }
    if (window.__flagshipSdkOnKeyCombinationUp) {
        document.removeEventListener('keyup', window.__flagshipSdkOnKeyCombinationUp);
    }
    const keysPressed = {};
    const keyCombinationPressed = () => {
        return (keysPressed.Control || keysPressed.Alt) && keysPressed.q && keysPressed.a;
    };
    window.__flagshipSdkOnKeyCombinationDown = (event) => {
        keysPressed[event.key] = true;
        sessionStorage.removeItem(FS_FORCED_VARIATIONS);
        if (keyCombinationPressed()) {
            loadQaAssistant(config, null, visitorVariationState);
        }
    };
    window.__flagshipSdkOnKeyCombinationUp = (event) => {
        delete keysPressed[event.key];
    };
    document.addEventListener('keydown', window.__flagshipSdkOnKeyCombinationDown);
    document.addEventListener('keyup', window.__flagshipSdkOnKeyCombinationUp);
}

function detectNavigationChanges(config, visitorVariationState, callback) {
    if (window.__flagshipSdkOriginalPushState) {
        window.history.pushState = window.__flagshipSdkOriginalPushState;
    }
    if (window.__flagshipSdkOriginalReplaceState) {
        window.history.replaceState = window.__flagshipSdkOriginalReplaceState;
    }
    if (window.__flagshipSdkPopStateHandler) {
        window.removeEventListener('popstate', window.__flagshipSdkPopStateHandler);
    }
    window.__flagshipSdkOriginalPushState = window.history.pushState;
    window.__flagshipSdkOriginalReplaceState = window.history.replaceState;
    function triggerCallback() {
        if (config.isQAModeEnabled) {
            visitorVariationState.navigationDetected = true;
        }
    }
    window.history.pushState = function (...args) {
        if (window.__flagshipSdkOriginalPushState) {
            window.__flagshipSdkOriginalPushState.apply(this, args);
            triggerCallback();
        }
    };
    window.history.replaceState = function (...args) {
        if (window.__flagshipSdkOriginalReplaceState) {
            window.__flagshipSdkOriginalReplaceState.apply(this, args);
            triggerCallback();
        }
    };
    window.__flagshipSdkPopStateHandler = () => {
        triggerCallback();
    };
    window.addEventListener('popstate', window.__flagshipSdkPopStateHandler);
}

/**
 *
 * @param config
 * @returns
 */
function launchQaAssistant(config, visitorVariationState) {
    if (!isBrowser()) {
        return;
    }
    onDomReady(() => {
        const urlMap = {
            [FS_QA_ASSISTANT]: QA_ASSISTANT_PROD_URL,
            [TAG_QA_ASSISTANT]: QA_ASSISTANT_PROD_URL,
            [FS_QA_ASSISTANT_STAGING]: QA_ASSISTANT_STAGING_URL,
            [TAG_QA_ASSISTANT_STAGING]: QA_ASSISTANT_STAGING_URL,
            [FS_QA_ASSISTANT_LOCAL]: QA_ASSISTANT_LOCAL_URL,
            [TAG_QA_ASSISTANT_LOCAL]: QA_ASSISTANT_LOCAL_URL
        };
        const queryParam = new URLSearchParams(window.location.search);
        const urlKey = Object.keys(urlMap).find((key) => queryParam.get(key) === 'true') || '';
        if (window.__flagshipSdkOnPlatformChoiceLoaded) {
            window.removeEventListener('message', window.__flagshipSdkOnPlatformChoiceLoaded);
        }
        function onPlatformChoiceLoaded(event) {
            if (!TRUSTED_QA_ORIGINS.includes(event.origin)) {
                return;
            }
            if (event.data.name === MSG_NAME_FROM_IFRAME.QaAssistantPlatformChoiceLoaded) {
                if (!config.isQAModeEnabled) {
                    loadQaAssistant(config, null, visitorVariationState);
                }
                window.removeEventListener('message', onPlatformChoiceLoaded);
            }
        }
        window.__flagshipSdkOnPlatformChoiceLoaded = onPlatformChoiceLoaded;
        window.addEventListener('message', window.__flagshipSdkOnPlatformChoiceLoaded);
        detectNavigationChanges(config, visitorVariationState);
        if (config.isQAModeEnabled || urlKey) {
            loadQaAssistant(config, urlMap[urlKey], visitorVariationState);
            return;
        }
        listenForKeyboardQaAssistant(config, visitorVariationState);
    });
}

export { launchQaAssistant };
//# sourceMappingURL=thfSquI5.js.map