@thoughtspot/visual-embed-sdk 1.20.2 → 1.20.3

package/cjs/src/embed/ts-embed.js

@@ -0,0 +1,719 @@
+"use strict";
+/**
+ * Copyright (c) 2022
+ *
+ * Base classes
+ *
+ * @summary Base classes
+ * @author Ayon Ghosh <ayon.ghosh@thoughtspot.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V1Embed = exports.TsEmbed = exports.THOUGHTSPOT_PARAM_PREFIX = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("../utils");
+const config_1 = require("../config");
+const types_1 = require("../types");
+const mixpanel_service_1 = require("../mixpanel-service");
+const processData_1 = require("../utils/processData");
+const processTrigger_1 = require("../utils/processTrigger");
+const package_json_1 = tslib_1.__importDefault(require("../../package.json"));
+const base_1 = require("./base");
+const auth_1 = require("../auth");
+const { version } = package_json_1.default;
+/**
+ * Global prefix for all Thoughtspot postHash Params.
+ */
+exports.THOUGHTSPOT_PARAM_PREFIX = 'ts-';
+const TS_EMBED_ID = '_thoughtspot-embed';
+/**
+ * The event id map from v2 event names to v1 event id
+ * v1 events are the classic embed events implemented in Blink v1
+ * We cannot rename v1 event types to maintain backward compatibility
+ *
+ * @internal
+ */
+const V1EventMap = {};
+/**
+ * Base class for embedding v2 experience
+ * Note: the v2 version of ThoughtSpot Blink is built on the new stack:
+ * React+GraphQL
+ */
+class TsEmbed {
+    constructor(domSelector, viewConfig) {
+        this.isAppInitialized = false;
+        /**
+         * Should we encode URL Query Params using base64 encoding which thoughtspot
+         * will generate for embedding. This provides additional security to
+         * thoughtspot clusters against Cross site scripting attacks.
+         *
+         * @default false
+         */
+        this.shouldEncodeUrlQueryParams = false;
+        this.defaultHiddenActions = [types_1.Action.ReportError];
+        /**
+         * Send Custom style as part of payload of APP_INIT
+         *
+         * @param _
+         * @param responder
+         */
+        this.appInitCb = async (_, responder) => {
+            let authToken = '';
+            if (this.embedConfig.authType === types_1.AuthType.TrustedAuthTokenCookieless) {
+                authToken = await (0, auth_1.getAuthenticaionToken)(this.embedConfig);
+            }
+            this.isAppInitialized = true;
+            responder({
+                type: types_1.EmbedEvent.APP_INIT,
+                data: {
+                    customisations: (0, utils_1.getCustomisations)(this.embedConfig, this.viewConfig),
+                    authToken,
+                },
+            });
+        };
+        /**
+         * Sends updated auth token to the iFrame to avoid user logout
+         *
+         * @param _
+         * @param responder
+         */
+        this.updateAuthToken = async (_, responder) => {
+            const { autoLogin = false, authType } = this.embedConfig; // Set autoLogin default to false
+            if (authType === types_1.AuthType.TrustedAuthTokenCookieless) {
+                const authToken = await (0, auth_1.getAuthenticaionToken)(this.embedConfig);
+                responder({
+                    type: types_1.EmbedEvent.AuthExpire,
+                    data: { authToken },
+                });
+            }
+            else if (autoLogin) {
+                (0, base_1.handleAuth)();
+            }
+            (0, base_1.notifyAuthFailure)(auth_1.AuthFailureType.EXPIRY);
+        };
+        /**
+         * Register APP_INIT event and sendback init payload
+         */
+        this.registerAppInit = () => {
+            this.on(types_1.EmbedEvent.APP_INIT, this.appInitCb);
+            this.on(types_1.EmbedEvent.AuthExpire, this.updateAuthToken);
+        };
+        this.el = (0, utils_1.getDOMNode)(domSelector);
+        // TODO: handle error
+        this.embedConfig = (0, base_1.getEmbedConfig)();
+        if (!this.embedConfig.authTriggerContainer && !this.embedConfig.useEventForSAMLPopup) {
+            this.embedConfig.authTriggerContainer = domSelector;
+        }
+        this.thoughtSpotHost = (0, config_1.getThoughtSpotHost)(this.embedConfig);
+        this.thoughtSpotV2Base = (0, config_1.getV2BasePath)(this.embedConfig);
+        this.eventHandlerMap = new Map();
+        this.isError = false;
+        this.viewConfig = viewConfig;
+        this.shouldEncodeUrlQueryParams = this.embedConfig.shouldEncodeUrlQueryParams;
+        this.registerAppInit();
+    }
+    /**
+     * Throws error encountered during initialization.
+     */
+    throwInitError() {
+        this.handleError('You need to init the ThoughtSpot SDK module first');
+    }
+    /**
+     * Handles errors within the SDK
+     *
+     * @param error The error message or object
+     */
+    handleError(error) {
+        this.isError = true;
+        this.executeCallbacks(types_1.EmbedEvent.Error, {
+            error,
+        });
+        // Log error
+        console.error(error);
+    }
+    /**
+     * Extracts the type field from the event payload
+     *
+     * @param event The window message event
+     */
+    getEventType(event) {
+        var _a, _b;
+        // eslint-disable-next-line no-underscore-dangle
+        return ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) || ((_b = event.data) === null || _b === void 0 ? void 0 : _b.__type);
+    }
+    /**
+     * Extracts the port field from the event payload
+     *
+     * @param event  The window message event
+     * @returns
+     */
+    getEventPort(event) {
+        if (event.ports.length && event.ports[0]) {
+            return event.ports[0];
+        }
+        return null;
+    }
+    /**
+     * fix for ts7.sep.cl
+     * will be removed for ts7.oct.cl
+     *
+     * @param event
+     * @param eventType
+     * @hidden
+     */
+    formatEventData(event, eventType) {
+        const eventData = {
+            ...event.data,
+            type: eventType,
+        };
+        if (!eventData.data) {
+            eventData.data = event.data.payload;
+        }
+        return eventData;
+    }
+    /**
+     * Adds a global event listener to window for "message" events.
+     * ThoughtSpot detects if a particular event is targeted to this
+     * embed instance through an identifier contained in the payload,
+     * and executes the registered callbacks accordingly.
+     */
+    subscribeToEvents() {
+        window.addEventListener('message', (event) => {
+            const eventType = this.getEventType(event);
+            const eventPort = this.getEventPort(event);
+            const eventData = this.formatEventData(event, eventType);
+            if (event.source === this.iFrame.contentWindow) {
+                this.executeCallbacks(eventType, (0, processData_1.processEventData)(eventType, eventData, this.thoughtSpotHost, this.el), eventPort);
+            }
+        });
+    }
+    /**
+     * Constructs the base URL string to load the ThoughtSpot app.
+     *
+     * @param query
+     */
+    getEmbedBasePath(query) {
+        let queryString = query;
+        if (this.shouldEncodeUrlQueryParams) {
+            queryString = `?base64UrlEncodedFlags=${(0, utils_1.getEncodedQueryParamsString)(queryString.substr(1))}`;
+        }
+        const basePath = [this.thoughtSpotHost, this.thoughtSpotV2Base, queryString]
+            .filter((x) => x.length > 0)
+            .join('/');
+        return `${basePath}#`;
+    }
+    /**
+     * Common query params set for all the embed modes.
+     *
+     * @param queryParams
+     * @returns queryParams
+     */
+    getBaseQueryParams(queryParams = {}) {
+        var _a, _b, _c;
+        let hostAppUrl = ((_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.host) || '';
+        // The below check is needed because TS Cloud firewall, blocks
+        // localhost/127.0.0.1 in any url param.
+        if (hostAppUrl.includes('localhost') || hostAppUrl.includes('127.0.0.1')) {
+            hostAppUrl = 'local-host';
+        }
+        queryParams[types_1.Param.HostAppUrl] = encodeURIComponent(hostAppUrl);
+        queryParams[types_1.Param.ViewPortHeight] = window.innerHeight;
+        queryParams[types_1.Param.ViewPortWidth] = window.innerWidth;
+        queryParams[types_1.Param.Version] = version;
+        queryParams[types_1.Param.AuthType] = this.embedConfig.authType;
+        if (this.embedConfig.disableLoginRedirect === true || this.embedConfig.autoLogin === true) {
+            queryParams[types_1.Param.DisableLoginRedirect] = true;
+        }
+        if (this.embedConfig.authType === types_1.AuthType.EmbeddedSSO) {
+            queryParams[types_1.Param.ForceSAMLAutoRedirect] = true;
+        }
+        if (this.embedConfig.authType === types_1.AuthType.TrustedAuthTokenCookieless) {
+            queryParams[types_1.Param.cookieless] = true;
+        }
+        const { disabledActions, disabledActionReason, hiddenActions, visibleActions, showAlerts, additionalFlags, locale, customizations, contextMenuTrigger, linkOverride, insertInToSlide, } = this.viewConfig;
+        if (Array.isArray(visibleActions) && Array.isArray(hiddenActions)) {
+            this.handleError('You cannot have both hidden actions and visible actions');
+            return queryParams;
+        }
+        // TODO remove embedConfig.customCssUrl
+        const cssUrlParam = ((_b = customizations === null || customizations === void 0 ? void 0 : customizations.style) === null || _b === void 0 ? void 0 : _b.customCSSUrl) || this.embedConfig.customCssUrl;
+        if (cssUrlParam) {
+            queryParams[types_1.Param.CustomCSSUrl] = cssUrlParam;
+        }
+        if (disabledActions === null || disabledActions === void 0 ? void 0 : disabledActions.length) {
+            queryParams[types_1.Param.DisableActions] = disabledActions;
+        }
+        if (disabledActionReason) {
+            queryParams[types_1.Param.DisableActionReason] = disabledActionReason;
+        }
+        queryParams[types_1.Param.HideActions] = [...this.defaultHiddenActions, ...(hiddenActions !== null && hiddenActions !== void 0 ? hiddenActions : [])];
+        if (Array.isArray(visibleActions)) {
+            queryParams[types_1.Param.VisibleActions] = visibleActions;
+        }
+        /**
+         * Default behavior for context menu will be left-click
+         *  from version 9.2.0.cl the user have an option to override context
+         *  menu click
+         */
+        if (contextMenuTrigger === types_1.ContextMenuTriggerOptions.LEFT_CLICK) {
+            queryParams[types_1.Param.ContextMenuTrigger] = true;
+        }
+        else if (contextMenuTrigger === types_1.ContextMenuTriggerOptions.RIGHT_CLICK) {
+            queryParams[types_1.Param.ContextMenuTrigger] = false;
+        }
+        const spriteUrl = (customizations === null || customizations === void 0 ? void 0 : customizations.iconSpriteUrl)
+            || ((_c = this.embedConfig.customizations) === null || _c === void 0 ? void 0 : _c.iconSpriteUrl);
+        if (spriteUrl) {
+            queryParams[types_1.Param.IconSpriteUrl] = spriteUrl.replace('https://', '');
+        }
+        if (showAlerts !== undefined) {
+            queryParams[types_1.Param.ShowAlerts] = showAlerts;
+        }
+        if (locale !== undefined) {
+            queryParams[types_1.Param.Locale] = locale;
+        }
+        if (additionalFlags && additionalFlags.constructor.name === 'Object') {
+            Object.assign(queryParams, additionalFlags);
+        }
+        if (linkOverride) {
+            queryParams[types_1.Param.LinkOverride] = linkOverride;
+        }
+        if (insertInToSlide) {
+            queryParams[types_1.Param.ShowInsertToSlide] = insertInToSlide;
+        }
+        return queryParams;
+    }
+    /**
+     * Constructs the base URL string to load v1 of the ThoughtSpot app.
+     * This is used for embedding Liveboards, visualizations, and full application.
+     *
+     * @param queryString The query string to append to the URL.
+     * @param isAppEmbed A Boolean parameter to specify if you are embedding
+     * the full application.
+     */
+    getV1EmbedBasePath(queryString) {
+        const queryParams = this.shouldEncodeUrlQueryParams
+            ? `?base64UrlEncodedFlags=${(0, utils_1.getEncodedQueryParamsString)(queryString)}`
+            : `?${queryString}`;
+        const path = `${this.thoughtSpotHost}/${queryParams}#`;
+        return path;
+    }
+    getEmbedParams() {
+        const queryParams = this.getBaseQueryParams();
+        return (0, utils_1.getQueryParamString)(queryParams);
+    }
+    getRootIframeSrc() {
+        const query = this.getEmbedParams();
+        return this.getEmbedBasePath(query);
+    }
+    createIframeEl(frameSrc) {
+        const iFrame = document.createElement('iframe');
+        iFrame.src = frameSrc;
+        iFrame.id = TS_EMBED_ID;
+        // according to screenfull.js documentation
+        // allowFullscreen, webkitallowfullscreen and mozallowfullscreen must be
+        // true
+        iFrame.allowFullscreen = true;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        iFrame.webkitallowfullscreen = true;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        iFrame.mozallowfullscreen = true;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        iFrame.allow = 'clipboard-read; clipboard-write';
+        const { height: frameHeight, width: frameWidth, ...restParams } = this.viewConfig.frameParams || {};
+        const width = (0, utils_1.getCssDimension)(frameWidth || config_1.DEFAULT_EMBED_WIDTH);
+        const height = (0, utils_1.getCssDimension)(frameHeight || config_1.DEFAULT_EMBED_HEIGHT);
+        (0, utils_1.setAttributes)(iFrame, restParams);
+        iFrame.style.width = `${width}`;
+        iFrame.style.height = `${height}`;
+        iFrame.style.border = '0';
+        iFrame.name = 'ThoughtSpot Embedded Analytics';
+        return iFrame;
+    }
+    /**
+     * Renders the embedded ThoughtSpot app in an iframe and sets up
+     * event listeners.
+     *
+     * @param url
+     * @param frameOptions
+     */
+    async renderIFrame(url) {
+        if (this.isError) {
+            return null;
+        }
+        if (!this.thoughtSpotHost) {
+            this.throwInitError();
+        }
+        if (url.length > config_1.URL_MAX_LENGTH) {
+            // warn: The URL is too long
+        }
+        return (0, base_1.renderInQueue)((nextInQueue) => {
+            var _a;
+            const initTimestamp = Date.now();
+            this.executeCallbacks(types_1.EmbedEvent.Init, {
+                data: {
+                    timestamp: initTimestamp,
+                },
+                type: types_1.EmbedEvent.Init,
+            });
+            (0, mixpanel_service_1.uploadMixpanelEvent)(mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_RENDER_START);
+            return (_a = (0, base_1.getAuthPromise)()) === null || _a === void 0 ? void 0 : _a.then((isLoggedIn) => {
+                if (!isLoggedIn) {
+                    this.insertIntoDOM(this.embedConfig.loginFailedMessage);
+                    return;
+                }
+                (0, mixpanel_service_1.uploadMixpanelEvent)(mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_RENDER_COMPLETE);
+                this.iFrame = this.iFrame || this.createIframeEl(url);
+                this.iFrame.addEventListener('load', () => {
+                    nextInQueue();
+                    const loadTimestamp = Date.now();
+                    this.executeCallbacks(types_1.EmbedEvent.Load, {
+                        data: {
+                            timestamp: loadTimestamp,
+                        },
+                        type: types_1.EmbedEvent.Load,
+                    });
+                    (0, mixpanel_service_1.uploadMixpanelEvent)(mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_IFRAME_LOAD_PERFORMANCE, {
+                        timeTookToLoad: loadTimestamp - initTimestamp,
+                    });
+                });
+                this.iFrame.addEventListener('error', () => {
+                    nextInQueue();
+                });
+                this.insertIntoDOM(this.iFrame);
+                const prefetchIframe = document.querySelectorAll('.prefetchIframe');
+                if (prefetchIframe.length) {
+                    prefetchIframe.forEach((el) => {
+                        el.remove();
+                    });
+                }
+                this.subscribeToEvents();
+            }).catch((error) => {
+                nextInQueue();
+                (0, mixpanel_service_1.uploadMixpanelEvent)(mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_RENDER_FAILED, {
+                    error: JSON.stringify(error),
+                });
+                this.insertIntoDOM(this.embedConfig.loginFailedMessage);
+                this.handleError(error);
+            });
+        });
+    }
+    insertIntoDOM(child) {
+        var _a;
+        if (this.viewConfig.insertAsSibling) {
+            if (typeof child === 'string') {
+                const div = document.createElement('div');
+                div.innerHTML = child;
+                div.id = TS_EMBED_ID;
+                // eslint-disable-next-line no-param-reassign
+                child = div;
+            }
+            if (((_a = this.el.nextElementSibling) === null || _a === void 0 ? void 0 : _a.id) === TS_EMBED_ID) {
+                this.el.nextElementSibling.remove();
+            }
+            this.el.parentElement.insertBefore(child, this.el.nextSibling);
+            this.insertedDomEl = child;
+        }
+        else if (typeof child === 'string') {
+            this.el.innerHTML = child;
+            this.insertedDomEl = this.el.children[0];
+        }
+        else {
+            this.el.innerHTML = '';
+            this.el.appendChild(child);
+            this.insertedDomEl = child;
+        }
+    }
+    /**
+     * Sets the height of the iframe
+     *
+     * @param height The height in pixels
+     */
+    setIFrameHeight(height) {
+        this.iFrame.style.height = (0, utils_1.getCssDimension)(height);
+    }
+    /**
+     * Executes all registered event handlers for a particular event type
+     *
+     * @param eventType The event type
+     * @param data The payload invoked with the event handler
+     * @param eventPort The event Port for a specific MessageChannel
+     */
+    executeCallbacks(eventType, data, eventPort) {
+        const eventHandlers = this.eventHandlerMap.get(eventType) || [];
+        const allHandlers = this.eventHandlerMap.get(types_1.EmbedEvent.ALL) || [];
+        const callbacks = [...eventHandlers, ...allHandlers];
+        const dataStatus = (data === null || data === void 0 ? void 0 : data.status) || utils_1.embedEventStatus.END;
+        callbacks.forEach((callbackObj) => {
+            if (
+            // When start status is true it trigger only start releated
+            // payload
+            (callbackObj.options.start && dataStatus === utils_1.embedEventStatus.START)
+                // When start status is false it trigger only end releated
+                // payload
+                || (!callbackObj.options.start && dataStatus === utils_1.embedEventStatus.END)) {
+                callbackObj.callback(data, (payload) => {
+                    this.triggerEventOnPort(eventPort, payload);
+                });
+            }
+        });
+    }
+    /**
+     * Returns the ThoughtSpot hostname or IP address.
+     */
+    getThoughtSpotHost() {
+        return this.thoughtSpotHost;
+    }
+    /**
+     * Gets the v1 event type (if applicable) for the EmbedEvent type
+     *
+     * @param eventType The v2 event type
+     * @returns The corresponding v1 event type if one exists
+     * or else the v2 event type itself
+     */
+    getCompatibleEventType(eventType) {
+        return V1EventMap[eventType] || eventType;
+    }
+    /**
+     * Calculates the iframe center for the current visible viewPort
+     * of iframe using Scroll position of Host App, offsetTop for iframe
+     * in Host app. ViewPort height of the tab.
+     *
+     * @returns iframe Center in visible viewport,
+     *  Iframe height,
+     *  View port height.
+     */
+    getIframeCenter() {
+        const offsetTopClient = (0, utils_1.getOffsetTop)(this.iFrame);
+        const scrollTopClient = window.scrollY;
+        const viewPortHeight = window.innerHeight;
+        const iframeHeight = this.iFrame.offsetHeight;
+        const iframeScrolled = scrollTopClient - offsetTopClient;
+        let iframeVisibleViewPort;
+        let iframeOffset;
+        if (iframeScrolled < 0) {
+            iframeVisibleViewPort = viewPortHeight - (offsetTopClient - scrollTopClient);
+            iframeVisibleViewPort = Math.min(iframeHeight, iframeVisibleViewPort);
+            iframeOffset = 0;
+        }
+        else {
+            iframeVisibleViewPort = Math.min(iframeHeight - iframeScrolled, viewPortHeight);
+            iframeOffset = iframeScrolled;
+        }
+        const iframeCenter = iframeOffset + iframeVisibleViewPort / 2;
+        return {
+            iframeCenter,
+            iframeScrolled,
+            iframeHeight,
+            viewPortHeight,
+            iframeVisibleViewPort,
+        };
+    }
+    /**
+     * Registers an event listener to trigger an alert when the ThoughtSpot app
+     * sends an event of a particular message type to the host application.
+     *
+     * @param messageType The message type
+     * @param callback A callback as a function
+     * @param options The message options
+     * @example
+     * ```js
+     * tsEmbed.on(EmbedEvent.Error, (data) => {
+     *   console.error(data);
+     * });
+     * ```
+     * @example
+     * ```js
+     * tsEmbed.on(EmbedEvent.Save, (data) => {
+     *   console.log("Answer save clicked", data);
+     * }, {
+     *   start: true // This will trigger the callback on start of save
+     * });
+     * ```
+     */
+    on(messageType, callback, options = { start: false }) {
+        if (this.isRendered) {
+            this.handleError('Please register event handlers before calling render');
+        }
+        const callbacks = this.eventHandlerMap.get(messageType) || [];
+        callbacks.push({ options, callback });
+        this.eventHandlerMap.set(messageType, callbacks);
+        return this;
+    }
+    /**
+     * Removes an event listener for a particular event type.
+     *
+     * @param messageType The message type
+     * @param callback The callback to remove
+     * @example
+     * ```js
+     * const errorHandler = (data) => { console.error(data); };
+     * tsEmbed.on(EmbedEvent.Error, errorHandler);
+     * tsEmbed.off(EmbedEvent.Error, errorHandler);
+     * ```
+     */
+    off(messageType, callback) {
+        const callbacks = this.eventHandlerMap.get(messageType) || [];
+        const index = callbacks.findIndex((cb) => cb.callback === callback);
+        if (index > -1) {
+            callbacks.splice(index, 1);
+        }
+        return this;
+    }
+    /**
+     * Triggers an event on specific Port registered against
+     * for the EmbedEvent
+     *
+     * @param eventType The message type
+     * @param data The payload to send
+     * @param eventPort
+     * @param payload
+     */
+    triggerEventOnPort(eventPort, payload) {
+        if (eventPort) {
+            try {
+                eventPort.postMessage({
+                    type: payload.type,
+                    data: payload.data,
+                });
+            }
+            catch (e) {
+                eventPort.postMessage({ error: e });
+                console.log(e);
+            }
+        }
+        else {
+            console.log('Event Port is not defined');
+        }
+    }
+    /**
+     * Triggers an event to the embedded app
+     *
+     * @param messageType The event type
+     * @param data The payload to send with the message
+     */
+    trigger(messageType, data = {}) {
+        (0, mixpanel_service_1.uploadMixpanelEvent)(`${mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_TRIGGER}-${messageType}`);
+        return (0, processTrigger_1.processTrigger)(this.iFrame, messageType, this.thoughtSpotHost, data);
+    }
+    /**
+     * Marks the ThoughtSpot object to have been rendered
+     * Needs to be overridden by subclasses to do the actual
+     * rendering of the iframe.
+     *
+     * @param args
+     */
+    render() {
+        this.isRendered = true;
+        return this;
+    }
+    /**
+     * Get the Post Url Params for THOUGHTSPOT from the current
+     * host app URL.
+     * THOUGHTSPOT URL params starts with a prefix "ts-"
+     *
+     * @version SDK: 1.14.0 | ThoughtSpot: 8.4.0.cl, 8.4.1-sw
+     */
+    getThoughtSpotPostUrlParams() {
+        const urlHash = window.location.hash;
+        const queryParams = window.location.search;
+        const postHashParams = urlHash.split('?');
+        const postURLParams = postHashParams[postHashParams.length - 1];
+        const queryParamsObj = new URLSearchParams(queryParams);
+        const postURLParamsObj = new URLSearchParams(postURLParams);
+        const params = new URLSearchParams();
+        const addKeyValuePairCb = (value, key) => {
+            if (key.startsWith(exports.THOUGHTSPOT_PARAM_PREFIX)) {
+                params.append(key, value);
+            }
+        };
+        queryParamsObj.forEach(addKeyValuePairCb);
+        postURLParamsObj.forEach(addKeyValuePairCb);
+        let tsParams = params.toString();
+        tsParams = tsParams ? `?${tsParams}` : '';
+        return tsParams;
+    }
+    /**
+     * Destroys the ThoughtSpot embed, and remove any nodes from the DOM.
+     *
+     * @version SDK: 1.19.1 | ThoughtSpot: *
+     */
+    destroy() {
+        try {
+            this.insertedDomEl.parentNode.removeChild(this.insertedDomEl);
+        }
+        catch (e) {
+            console.log('Error destroying TS Embed', e);
+        }
+    }
+    getUnderlyingFrameElement() {
+        return this.iFrame;
+    }
+    /**
+     * Prerenders a generic instance of the TS component.
+     * This means without the path but with the flags already applied.
+     * This is useful for prerendering the component in the background.
+     *
+     * @version SDK: 1.22.0
+     * @returns
+     */
+    async prerenderGeneric() {
+        const prerenderFrameSrc = this.getRootIframeSrc();
+        return this.renderIFrame(prerenderFrameSrc);
+    }
+}
+exports.TsEmbed = TsEmbed;
+/**
+ * Base class for embedding v1 experience
+ * Note: The v1 version of ThoughtSpot Blink works on the AngularJS stack
+ * which is currently under migration to v2
+ *
+ * @inheritdoc
+ */
+class V1Embed extends TsEmbed {
+    constructor(domSelector, viewConfig) {
+        super(domSelector, viewConfig);
+        this.viewConfig = viewConfig;
+    }
+    /**
+     * Render the ap    p in an iframe and set up event handlers
+     *
+     * @param iframeSrc
+     */
+    renderV1Embed(iframeSrc) {
+        return this.renderIFrame(iframeSrc);
+    }
+    getRootIframeSrc() {
+        const runtimeFilters = this.viewConfig.runtimeFilters;
+        const filterQuery = (0, utils_1.getFilterQuery)(runtimeFilters || []);
+        const queryParams = this.getEmbedParams();
+        const queryString = [filterQuery, queryParams].filter(Boolean).join('&');
+        return this.getV1EmbedBasePath(queryString);
+    }
+    /**
+     * @inheritdoc
+     * @example
+     * ```js
+     * tsEmbed.on(EmbedEvent.Error, (data) => {
+     *   console.error(data);
+     * });
+     * ```
+     * @example
+     * ```js
+     * tsEmbed.on(EmbedEvent.Save, (data) => {
+     *   console.log("Answer save clicked", data);
+     * }, {
+     *   start: true // This will trigger the callback on start of save
+     * });
+     * ```
+     */
+    on(messageType, callback, options = { start: false }) {
+        const eventType = this.getCompatibleEventType(messageType);
+        (0, mixpanel_service_1.uploadMixpanelEvent)(`${mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_ON}-${messageType}`);
+        return super.on(eventType, callback, options);
+    }
+}
+exports.V1Embed = V1Embed;
+//# sourceMappingURL=ts-embed.js.map