@flagship.io/js-sdk
Version:
469 lines (427 loc) • 18.3 kB
JavaScript
;
(self["webpackChunk_flagship_io_js_sdk"] = self["webpackChunk_flagship_io_js_sdk"] || []).push([[104],{
/***/ 104:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
launchQaAssistant: () => (/* binding */ launchQaAssistant)
});
// EXTERNAL MODULE: ./src/enum/FlagshipConstant.ts
var FlagshipConstant = __webpack_require__(87);
// EXTERNAL MODULE: ./src/utils/utils.ts
var utils = __webpack_require__(686);
;// ./src/qaAssistant/web/appendScript.ts
const getScriptElement = (src) => document.querySelector(`script[src*="${src}"]`);
/**
*
* @param bundleFileUrl
*/
function appendScript(bundleFileUrl) {
if (getScriptElement(FlagshipConstant.TAG_QA_URL) || getScriptElement(FlagshipConstant.FS_QA_URL)) {
return;
}
const script = document.createElement('script');
script.src = bundleFileUrl;
script.id = FlagshipConstant.FS_QA_ASSISTANT_SCRIPT_TAG_ID;
if (bundleFileUrl === FlagshipConstant.QA_ASSISTANT_LOCAL_URL) {
script.crossOrigin = 'anonymous';
}
document.body.append(script);
}
// EXTERNAL MODULE: ./src/qaAssistant/web/type.ts
var type = __webpack_require__(429);
// EXTERNAL MODULE: ./src/qaAssistant/web/messages/index.ts
var messages = __webpack_require__(586);
;// ./src/qaAssistant/web/messages/iframeMessageActions.ts
function onQaAssistantReady(visitorVariationState) {
if (visitorVariationState.visitorVariations) {
(0,messages.sendVisitorAllocatedVariations)(visitorVariationState);
}
if (visitorVariationState.exposedVariations) {
(0,messages.sendVisitorExposedVariations)(visitorVariationState);
}
}
function render(forcedReFetchFlags = false) {
if (FlagshipConstant.SDK_INFO.name === 'TypeScript') {
window.location.reload();
}
const triggerRenderEvent = new CustomEvent(type.INTERNAL_EVENTS.FsTriggerRendering, { detail: { forcedReFetchFlags } });
window.dispatchEvent(triggerRenderEvent);
}
function onQaAssistantClose({ config, func, visitorVariationState }) {
config.isQAModeEnabled = false;
sessionStorage.removeItem(FlagshipConstant.FS_IS_QA_MODE_ENABLED);
if (func) {
window.removeEventListener('message', func);
}
document.getElementById(FlagshipConstant.FS_QA_ASSISTANT_SCRIPT_TAG_ID)?.remove();
visitorVariationState.forcedVariations = {};
render();
}
function onApplyForcedVariations({ value, visitorVariationState }) {
const sessionForcedVariations = sessionStorage.getItem(FlagshipConstant.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(FlagshipConstant.FS_FORCED_VARIATIONS, JSON.stringify(forcedVariations));
visitorVariationState.forcedVariations = forcedVariations;
render();
}
function onResetForcedVariations(visitorVariationState) {
sessionStorage.removeItem(FlagshipConstant.FS_FORCED_VARIATIONS);
visitorVariationState.forcedVariations = {};
render();
}
function removeForcedVariation(keys, visitorVariationState) {
const sessionForcedVariations = sessionStorage.getItem(FlagshipConstant.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(FlagshipConstant.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(FlagshipConstant.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(FlagshipConstant.FS_VARIATIONS_FORCED_UNALLOCATION, JSON.stringify(value));
visitorVariationState.variationsForcedUnallocation = value;
visitorVariationState.shouldForceRender = true;
render(true);
}
;// ./src/qaAssistant/web/messages/handleIframeMessage.ts
function handleIframeMessage({ event, config, func, visitorVariationState }) {
if (!config.isQAModeEnabled || !(0,utils.isBrowser)()) {
return;
}
switch (event.data.name) {
case type.MSG_NAME_FROM_IFRAME.FsQaAssistantReady:
onQaAssistantReady(visitorVariationState);
break;
case type.MSG_NAME_FROM_IFRAME.MinimizeQaAssistantClose:
case type.MSG_NAME_FROM_IFRAME.QaAssistantClose:
onQaAssistantClose({
config,
func,
visitorVariationState
});
break;
case type.MSG_NAME_FROM_IFRAME.FsApplyForcedVariations:
onApplyForcedVariations({
value: event.data.value,
visitorVariationState
});
break;
case type.MSG_NAME_FROM_IFRAME.FsResetForcedVariations:
onResetForcedVariations(visitorVariationState);
break;
case type.MSG_NAME_FROM_IFRAME.FsTriggerRender:
render(true);
break;
case type.MSG_NAME_FROM_IFRAME.FsVariationsForcedAllocation:
onVariationsForcedAllocation({
value: event.data.value,
visitorVariationState
});
break;
case type.MSG_NAME_FROM_IFRAME.FsVariationsForcedUnallocation:
onVariationsForcedUnallocation({
value: event.data.value,
visitorVariationState
});
break;
case type.MSG_NAME_FROM_IFRAME.FsRemoveForcedVariation:
onRemoveForcedVariation({
keys: event.data.value,
visitorVariationState
});
break;
}
}
;// ./src/qaAssistant/web/loadQaAssistant.ts
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) {
(0,utils.logInfoSprintf)(config, 'QA assistant', 'Loading QA Assistant');
appendScript(bundleUrl || FlagshipConstant.QA_ASSISTANT_PROD_URL);
}
visitorVariationState.forcedVariations = loadSessionVariations(FlagshipConstant.FS_FORCED_VARIATIONS);
visitorVariationState.variationsForcedAllocation = loadSessionVariations(FlagshipConstant.FS_VARIATIONS_FORCED_ALLOCATION);
;
visitorVariationState.variationsForcedUnallocation = loadSessionVariations(FlagshipConstant.FS_VARIATIONS_FORCED_UNALLOCATION);
;
if (window.__flagshipSdkQaAssistantMessageHandler) {
window.removeEventListener('message', window.__flagshipSdkQaAssistantMessageHandler);
}
const eventListenerMessage = (event) => {
if (!FlagshipConstant.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(FlagshipConstant.FS_IS_QA_MODE_ENABLED, 'true');
}
;// ./src/qaAssistant/web/listenForKeyboardQaAssistant.ts
/**
*
* @param config
*/
function listenForKeyboardQaAssistant(config, visitorVariationState) {
(0,utils.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(FlagshipConstant.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);
}
;// ./src/qaAssistant/web/detectNavigationChanges.ts
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;
callback?.();
}
}
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);
}
;// ./src/qaAssistant/web/index.ts
/**
*
* @param config
* @returns
*/
function launchQaAssistant(config, visitorVariationState) {
if (!(0,utils.isBrowser)()) {
return;
}
(0,utils.onDomReady)(() => {
const urlMap = {
[FlagshipConstant.FS_QA_ASSISTANT]: FlagshipConstant.QA_ASSISTANT_PROD_URL,
[FlagshipConstant.TAG_QA_ASSISTANT]: FlagshipConstant.QA_ASSISTANT_PROD_URL,
[FlagshipConstant.FS_QA_ASSISTANT_STAGING]: FlagshipConstant.QA_ASSISTANT_STAGING_URL,
[FlagshipConstant.TAG_QA_ASSISTANT_STAGING]: FlagshipConstant.QA_ASSISTANT_STAGING_URL,
[FlagshipConstant.FS_QA_ASSISTANT_LOCAL]: FlagshipConstant.QA_ASSISTANT_LOCAL_URL,
[FlagshipConstant.TAG_QA_ASSISTANT_LOCAL]: FlagshipConstant.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 (!FlagshipConstant.TRUSTED_QA_ORIGINS.includes(event.origin)) {
return;
}
if (event.data.name === type.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);
});
}
/***/ }),
/***/ 429:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ INTERNAL_EVENTS: () => (/* binding */ INTERNAL_EVENTS),
/* harmony export */ MSG_NAME_FROM_IFRAME: () => (/* binding */ MSG_NAME_FROM_IFRAME),
/* harmony export */ MSG_NAME_TO_IFRAME: () => (/* binding */ MSG_NAME_TO_IFRAME),
/* harmony export */ VisitorVariationUpdateParam: () => (/* binding */ VisitorVariationUpdateParam)
/* harmony export */ });
/**
* All events posted from iframe
*/
var MSG_NAME_FROM_IFRAME;
(function (MSG_NAME_FROM_IFRAME) {
MSG_NAME_FROM_IFRAME["QaAssistantClose"] = "ABTASTY_QA_ASSISTANT_CLOSE";
MSG_NAME_FROM_IFRAME["FsApplyForcedVariations"] = "FS_APPLY_FORCED_VARIATIONS";
MSG_NAME_FROM_IFRAME["FsResetForcedVariations"] = "FS_RESET_FORCED_VARIATIONS";
MSG_NAME_FROM_IFRAME["FsRemoveForcedVariation"] = "FS_REMOVE_FORCED_VARIATION";
MSG_NAME_FROM_IFRAME["FsQaAssistantReady"] = "FS_QA_ASSISTANT_READY";
MSG_NAME_FROM_IFRAME["MinimizeQaAssistantClose"] = "ABTASTY_QA_MINIMIZE_QA_ASSISTANT_CLOSE";
MSG_NAME_FROM_IFRAME["FsTriggerRender"] = "FS_TRIGGER_RENDER";
MSG_NAME_FROM_IFRAME["QaAssistantPlatformChoiceLoaded"] = "ABTASTY_QA_ASSISTANT_PLATFORM_CHOICE_LOADED";
MSG_NAME_FROM_IFRAME["FsVariationsForcedAllocation"] = "FS_VARIATIONS_FORCED_ALLOCATION";
MSG_NAME_FROM_IFRAME["FsVariationsForcedUnallocation"] = "FS_VARIATIONS_FORCED_UNALLOCATION";
})(MSG_NAME_FROM_IFRAME || (MSG_NAME_FROM_IFRAME = {}));
/**
* All events posted to iframe
*/
var MSG_NAME_TO_IFRAME;
(function (MSG_NAME_TO_IFRAME) {
MSG_NAME_TO_IFRAME["FsUpdateVisitorAllocatedVariation"] = "FS_UPDATE_VISITOR_ALLOCATED_VARIATION";
MSG_NAME_TO_IFRAME["FsVisitorExposedVariation"] = "FS_VISITOR_EXPOSED_VARIATION";
MSG_NAME_TO_IFRAME["FsHIT"] = "FS_HIT";
})(MSG_NAME_TO_IFRAME || (MSG_NAME_TO_IFRAME = {}));
var VisitorVariationUpdateParam;
(function (VisitorVariationUpdateParam) {
VisitorVariationUpdateParam["NewNavigation"] = "newNavigation";
})(VisitorVariationUpdateParam || (VisitorVariationUpdateParam = {}));
var INTERNAL_EVENTS;
(function (INTERNAL_EVENTS) {
INTERNAL_EVENTS["FsTriggerRendering"] = "FS_TRIGGER_RENDERING";
})(INTERNAL_EVENTS || (INTERNAL_EVENTS = {}));
/***/ }),
/***/ 586:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ sendFsHitToQA: () => (/* binding */ sendFsHitToQA),
/* harmony export */ sendVisitorAllocatedVariations: () => (/* binding */ sendVisitorAllocatedVariations),
/* harmony export */ sendVisitorExposedVariations: () => (/* binding */ sendVisitorExposedVariations)
/* harmony export */ });
/* unused harmony export sendMessageToIframe */
/* harmony import */ var _type__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(429);
function sendMessageToIframe(data) {
if (!window?.frames?.ABTastyQaAssistant) {
return;
}
window.frames.ABTastyQaAssistant.postMessage(data, '*');
}
function sendVisitorAllocatedVariations(visitorVariationState) {
if (!visitorVariationState?.visitorVariations) {
return;
}
sendMessageToIframe({
name: _type__WEBPACK_IMPORTED_MODULE_0__.MSG_NAME_TO_IFRAME.FsUpdateVisitorAllocatedVariation,
value: visitorVariationState.visitorVariations,
visitorData: visitorVariationState.visitorData,
sdkInfo: visitorVariationState.sdkInfo
});
}
function sendVisitorExposedVariations(visitorVariationState) {
if (!visitorVariationState?.exposedVariations) {
return;
}
const navigationDetected = visitorVariationState.navigationDetected;
if (visitorVariationState.navigationDetected) {
visitorVariationState.navigationDetected = false;
}
sendMessageToIframe({
name: _type__WEBPACK_IMPORTED_MODULE_0__.MSG_NAME_TO_IFRAME.FsVisitorExposedVariation,
value: visitorVariationState.exposedVariations,
param: navigationDetected ? _type__WEBPACK_IMPORTED_MODULE_0__.VisitorVariationUpdateParam.NewNavigation : undefined
});
}
function sendFsHitToQA(hit) {
sendMessageToIframe({
name: _type__WEBPACK_IMPORTED_MODULE_0__.MSG_NAME_TO_IFRAME.FsHIT,
value: hit.map(item => {
return {
...item,
timestamp: Date.now() - item.qt
};
})
});
}
/***/ })
}]);
//# sourceMappingURL=104.002df3b6fd8c928dfb02.js.map