@thoughtspot/visual-embed-sdk 1.44.0 → 1.44.1-test

package/src/embed/base.ts

@@ -35,6 +35,7 @@ import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
 import { getEmbedConfig, setEmbedConfig } from './embedConfig';
 import { getQueryParamString, getValueFromWindow, storeValueInWindow } from '../utils';
 import { resetAllCachedServices } from '../utils/resetServices';
+import { reload } from '../utils/processTrigger';
 
 const CONFIG_DEFAULTS: Partial<EmbedConfig> = {
     loginFailedMessage: 'Not logged in',
@@ -459,3 +460,17 @@ export function reset(): void {
     setAuthEE(null);
     authPromise = null;
 }
+
+/**
+ * Reloads the ThoughtSpot iframe.
+ * @param iFrame
+ * @group Global methods
+ * @version SDK: 1.43.1
+ */
+export const reloadIframe = (iFrame: HTMLIFrameElement) => {
+    if (!iFrame) {
+        logger.warn('reloadIframe called with no iFrame element.');
+        return;
+    }
+    reload(iFrame);
+};

package/src/embed/conversation.spec.ts

@@ -2,7 +2,7 @@ import { SpotterEmbed, SpotterEmbedViewConfig, ConversationEmbed } from './conve
 import { TsEmbed } from './ts-embed';
 import * as authInstance from '../auth';
 import { Action, init } from '../index';
-import { AuthType, Param, RuntimeFilterOp } from '../types';
+import { AuthType, Param, RuntimeFilterOp, ErrorDetailsTypes, EmbedErrorCodes  } from '../types';
 import {
     getDocumentBody,
     getIFrameSrc,
@@ -120,7 +120,12 @@ describe('ConversationEmbed', () => {
         (conversationEmbed as any).handleError = jest.fn();
         await conversationEmbed.render();
         expect((conversationEmbed as any).handleError).toHaveBeenCalledWith(
-            ERROR_MESSAGE.SPOTTER_EMBED_WORKSHEED_ID_NOT_FOUND,
+            {
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.SPOTTER_EMBED_WORKSHEED_ID_NOT_FOUND,
+                code: EmbedErrorCodes.WORKSHEET_ID_NOT_FOUND,
+                error: ERROR_MESSAGE.SPOTTER_EMBED_WORKSHEED_ID_NOT_FOUND,
+            },
         );
     });
 

package/src/embed/conversation.ts

@@ -1,6 +1,6 @@
 import isUndefined from 'lodash/isUndefined';
 import { ERROR_MESSAGE } from '../errors';
-import { Param, BaseViewConfig, RuntimeFilter, RuntimeParameter } from '../types';
+import { Param, BaseViewConfig, RuntimeFilter, RuntimeParameter, ErrorDetailsTypes, EmbedErrorCodes } from '../types';
 import { TsEmbed } from './ts-embed';
 import { getQueryParamString, getFilterQuery, getRuntimeParameters } from '../utils';
 
@@ -246,7 +246,12 @@ export class SpotterEmbed extends TsEmbed {
         } = this.viewConfig;
 
         if (!worksheetId) {
-            this.handleError(ERROR_MESSAGE.SPOTTER_EMBED_WORKSHEED_ID_NOT_FOUND);
+            this.handleError({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.SPOTTER_EMBED_WORKSHEED_ID_NOT_FOUND,
+                code: EmbedErrorCodes.WORKSHEET_ID_NOT_FOUND,
+                error: ERROR_MESSAGE.SPOTTER_EMBED_WORKSHEED_ID_NOT_FOUND,
+            });
         }
         const queryParams = this.getBaseQueryParams();
         queryParams[Param.SpotterEnabled] = true;

package/src/embed/liveboard.spec.ts

@@ -407,6 +407,70 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('Should add showMaskedFilterChip flag set to true to the iframe src', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            showMaskedFilterChip: true,
+        } as LiveboardViewConfig);
+
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&showMaskedFilterChip=true${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
+    test('Should add showMaskedFilterChip flag set to false to the iframe src', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            showMaskedFilterChip: false,
+        } as LiveboardViewConfig);
+
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&showMaskedFilterChip=false${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
+    test('Should add isLiveboardMasterpiecesEnabled flag set to true to the iframe src', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            isLiveboardMasterpiecesEnabled: true,
+        } as LiveboardViewConfig);
+
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isLiveboardMasterpiecesEnabled=true${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
+    test('Should add isLiveboardMasterpiecesEnabled flag set to false to the iframe src', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            isLiveboardMasterpiecesEnabled: false,
+        } as LiveboardViewConfig);
+
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isLiveboardMasterpiecesEnabled=false${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
     test('Should add hideIrrelevantFiltersAtTabLevel flag to the iframe src', async () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             ...defaultViewConfig,
@@ -1587,4 +1651,47 @@ describe('Liveboard/viz embed tests', () => {
             expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, undefined, undefined);
         });
     });
+
+    describe('Liveboard Embed Default Height and Minimum Height Handling', () => {
+        test('should set default height to 800 when minimum height is provided', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+                defaultHeight: 700,
+                minimumHeight: 800,
+            });
+            await liveboardEmbed.render();
+            expect(liveboardEmbed['defaultHeight']).toBe(800);
+        });
+        test('should set default height to 700 when default height is provided', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+                defaultHeight: 700,
+            });
+            await liveboardEmbed.render();
+            expect(liveboardEmbed['defaultHeight']).toBe(700);
+        });
+        test('should set default height to 800 when minimum height is provided but default height is not', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+                minimumHeight: 800,
+            });
+            await liveboardEmbed.render();
+            expect(liveboardEmbed['defaultHeight']).toBe(800);
+        });
+        test('should set default height to 500 when neither default height nor minimum height is provided', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+            });
+            await liveboardEmbed.render();
+            expect(liveboardEmbed['defaultHeight']).toBe(500);
+        });
+    });
 });

package/src/embed/liveboard.ts

@@ -20,6 +20,8 @@ import {
     SearchLiveboardCommonViewConfig as LiveboardOtherViewConfig,
     BaseViewConfig,
     LiveboardAppEmbedViewConfig,
+    ErrorDetailsTypes,
+    EmbedErrorCodes,
 } from '../types';
 import { calculateVisibleElementData, getQueryParamString, isUndefined } from '../utils';
 import { getAuthPromise } from './base';
@@ -65,6 +67,7 @@ export interface LiveboardViewConfig extends BaseViewConfig, LiveboardOtherViewC
      * Supported embed types: `LiveboardEmbed`
      * @version SDK: 1.5.0 | ThoughtSpot: ts7.oct.cl, 7.2.1
      * @default 500
+     * @deprecated Use `minimumHeight` instead.
      * @example
      * ```js
      * const embed = new LiveboardEmbed('#embed', {
@@ -75,6 +78,23 @@ export interface LiveboardViewConfig extends BaseViewConfig, LiveboardOtherViewC
      * ```
      */
     defaultHeight?: number;
+    /**
+     * This is the minimum height (in pixels) for a full-height Liveboard.
+     * Setting this height helps resolve issues with empty Liveboards and
+     * other screens navigable from a Liveboard.
+     *
+     * @version SDK: 1.44.2 | ThoughtSpot: 26.0.2.cl
+     * @default 500
+     * @example
+     * ```js
+     * const embed = new LiveboardEmbed('#embed', {
+     *   ... // other liveboard view config
+     *   fullHeight: true,
+     *   minimumHeight: 600,
+     * });
+     * ```
+     */
+    minimumHeight?: number;
     /**
      * @Deprecated If set to true, the context menu in visualizations will be enabled.
      * @example
@@ -467,6 +487,7 @@ export class LiveboardEmbed extends V1Embed {
             enableVizTransformations,
             fullHeight,
             defaultHeight,
+            minimumHeight,
             visibleVizs,
             liveboardV2,
             vizId,
@@ -480,6 +501,8 @@ export class LiveboardEmbed extends V1Embed {
             showLiveboardVerifiedBadge = true,
             showLiveboardReverifyBanner = true,
             hideIrrelevantChipsInLiveboardTabs = false,
+            showMaskedFilterChip = false,
+            isLiveboardMasterpiecesEnabled = false,
             isEnhancedFilterInteractivityEnabled = false,
             enableAskSage,
             enable2ColumnLayout,
@@ -508,9 +531,7 @@ export class LiveboardEmbed extends V1Embed {
                 params[Param.RootMarginForLazyLoad] = this.viewConfig.lazyLoadingMargin;
             }
         }
-        if (defaultHeight) {
-            this.defaultHeight = defaultHeight;
-        }
+        this.defaultHeight = minimumHeight || defaultHeight || this.defaultHeight;
         if (enableVizTransformations !== undefined) {
             params[Param.EnableVizTransformations] = enableVizTransformations.toString();
         }
@@ -589,6 +610,8 @@ export class LiveboardEmbed extends V1Embed {
         params[Param.ShowLiveboardVerifiedBadge] = showLiveboardVerifiedBadge;
         params[Param.ShowLiveboardReverifyBanner] = showLiveboardReverifyBanner;
         params[Param.HideIrrelevantFiltersInTab] = hideIrrelevantChipsInLiveboardTabs;
+        params[Param.ShowMaskedFilterChip] = showMaskedFilterChip;
+        params[Param.IsLiveboardMasterpiecesEnabled] = isLiveboardMasterpiecesEnabled;
         params[Param.IsEnhancedFilterInteractivityEnabled] = isEnhancedFilterInteractivityEnabled;
         params[Param.DataPanelV2Enabled] = dataPanelV2;
         params[Param.EnableCustomColumnGroups] = enableCustomColumnGroups;
@@ -642,7 +665,12 @@ export class LiveboardEmbed extends V1Embed {
         const liveboardId = this.viewConfig.liveboardId ?? this.viewConfig.pinboardId;
 
         if (!liveboardId) {
-            this.handleError(ERROR_MESSAGE.LIVEBOARD_VIZ_ID_VALIDATION);
+            this.handleError({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.LIVEBOARD_VIZ_ID_VALIDATION,
+                code: EmbedErrorCodes.LIVEBOARD_ID_MISSING,
+                error: ERROR_MESSAGE.LIVEBOARD_VIZ_ID_VALIDATION,
+            });
         }
         return `${this.getRootIframeSrc()}${this.getIframeSuffixSrc(
             liveboardId,

package/src/embed/ts-embed.spec.ts

@@ -29,6 +29,8 @@ import {
     CustomActionTarget,
     CustomActionsPosition,
     DefaultAppInitData,
+    ErrorDetailsTypes,
+    EmbedErrorCodes,
 } from '../types';
 import {
     executeAfterWait,
@@ -1613,9 +1615,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await pinboardEmbed.render();
             expect(pinboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith(
-                'You cannot have both hidden actions and visible actions',
-            );
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_ACTIONS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+            });
         });
         test('should not throw error when there are only visible or hidden actions - pinboard', async () => {
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
@@ -1645,9 +1650,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await liveboardEmbed.render();
             expect(liveboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith(
-                'You cannot have both hidden actions and visible actions',
-            );
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_ACTIONS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+            });
         }
         test('should throw error when there are both visible and hidden action arrays', async () => {
             await testActionsForLiveboards([Action.DownloadAsCsv], [Action.DownloadAsCsv]);
@@ -1690,9 +1698,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await pinboardEmbed.render();
             expect(pinboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith(
-                'You cannot have both hidden Tabs and visible Tabs',
-            );
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_TABS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+            });
         });
         test('should not throw error when there are only visible or hidden Tabs - pinboard', async () => {
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
@@ -1722,9 +1733,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await liveboardEmbed.render();
             expect(liveboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith(
-                'You cannot have both hidden Tabs and visible Tabs',
-            );
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_TABS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+            });
         }
         test('should throw error when there are both visible and hidden Tab arrays', async () => {
             await testTabsForLiveboards([tabId1], [tabId2]);
@@ -1770,9 +1784,12 @@ describe('Unit test case for ts embed', () => {
             const tsEmbed = new SearchEmbed(getRootEl(), {});
             await tsEmbed.render();
             expect(tsEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith(
-                'You need to init the ThoughtSpot SDK module first',
-            );
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.INIT_SDK_REQUIRED,
+                code: EmbedErrorCodes.INIT_ERROR,
+                error: ERROR_MESSAGE.INIT_SDK_REQUIRED,
+            });
         });
     });
 
@@ -3829,3 +3846,78 @@ describe('Unit test case for ts embed', () => {
         });
     });
 });
+
+
+describe('Additional Coverage Tests', () => {
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+        });
+    });
+
+    test('should handle getAuthTokenForCookielessInit with non-cookieless auth', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const token = await searchEmbed['getAuthTokenForCookielessInit']();
+        expect(token).toBe('');
+    });
+
+    test('should call setIFrameHeight', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        await searchEmbed.render();
+        await executeAfterWait(() => {
+            searchEmbed['setIFrameHeight'](500);
+            expect(getIFrameEl().style.height).toBe('500px');
+        });
+    });
+
+    test('should test getIframeCenter calculation', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        await searchEmbed.render();
+        await executeAfterWait(() => {
+            const center = searchEmbed['getIframeCenter']();
+            expect(center).toHaveProperty('iframeCenter');
+            expect(center).toHaveProperty('iframeHeight');
+            expect(center).toHaveProperty('viewPortHeight');
+        });
+    });
+
+    test('should handle preRender with replaceExistingPreRender=true', async () => {
+        createRootEleForEmbed();
+        const embed1 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'test-replace',
+            liveboardId: 'lb1',
+        });
+        await embed1.preRender();
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'test-replace',
+            liveboardId: 'lb2',
+        });
+        await embed2.preRender(false, true);
+        expect(document.getElementById('tsEmbed-pre-render-wrapper-test-replace')).toBeTruthy();
+    });
+
+    test('should test getIframeSrc base implementation', () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        expect(searchEmbed.getIframeSrc()).toBe('');
+    });
+
+    test('should handle createEmbedEventResponder with OnBeforeGetVizDataIntercept', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const mockPort: any = { postMessage: jest.fn() };
+        const responder = searchEmbed['createEmbedEventResponder'](
+            mockPort,
+            EmbedEvent.OnBeforeGetVizDataIntercept,
+        );
+        responder({ data: 'test' });
+        expect(mockPort.postMessage).toHaveBeenCalled();
+    });
+
+    test('should clean up message event listeners', async () => {
+        const removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        await searchEmbed.render();
+        searchEmbed['unsubscribeToMessageEvents']();
+        expect(removeEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
+    });
+});

package/src/embed/ts-embed.ts

@@ -57,6 +57,9 @@ import {
     ContextMenuTriggerOptions,
     DefaultAppInitData,
     AllEmbedViewConfig as ViewConfig,
+    EmbedErrorDetailsEvent,
+    ErrorDetailsTypes,
+    EmbedErrorCodes,
 } from '../types';
 import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
 import { processEventData, processAuthFailure } from '../utils/processData';
@@ -218,20 +221,24 @@ export class TsEmbed {
      * Throws error encountered during initialization.
      */
     private throwInitError() {
-        this.handleError('You need to init the ThoughtSpot SDK module first');
+        this.handleError({
+            errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+            message: ERROR_MESSAGE.INIT_SDK_REQUIRED,
+            code: EmbedErrorCodes.INIT_ERROR,
+            error : ERROR_MESSAGE.INIT_SDK_REQUIRED,
+        });
     }
 
     /**
      * Handles errors within the SDK
      * @param error The error message or object
+     * @param errorDetails The error details
      */
-    protected handleError(error: string | Record<string, unknown>) {
+    protected handleError(errorDetails: EmbedErrorDetailsEvent) {
         this.isError = true;
-        this.executeCallbacks(EmbedEvent.Error, {
-            error,
-        });
+        this.executeCallbacks(EmbedEvent.Error, errorDetails);
         // Log error
-        logger.error(error);
+        logger.error(errorDetails);
     }
 
     /**
@@ -325,11 +332,14 @@ export class TsEmbed {
         window.addEventListener('online', onlineEventListener);
 
         const offlineEventListener = (e: Event) => {
-            const offlineWarning = ERROR_MESSAGE.OFFLINE_WARNING;
-            this.executeCallbacks(EmbedEvent.Error, {
-                offlineWarning,
-            });
-            logger.warn(offlineWarning);
+            const errorDetails = {
+                errorType: ErrorDetailsTypes.NETWORK,
+                message: ERROR_MESSAGE.OFFLINE_WARNING,
+                code: EmbedErrorCodes.NETWORK_ERROR,
+                offlineWarning : ERROR_MESSAGE.OFFLINE_WARNING,
+            };
+            this.executeCallbacks(EmbedEvent.Error, errorDetails);
+            logger.warn(errorDetails);
         };
         window.addEventListener('offline', offlineEventListener);
 
@@ -444,9 +454,11 @@ export class TsEmbed {
         ]);
         if (customActionsResult.errors.length > 0) {
             this.handleError({
-                type: 'CUSTOM_ACTION_VALIDATION',
-                message: customActionsResult.errors,
-            });
+                    errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                    message: customActionsResult.errors,
+                    code: EmbedErrorCodes.CUSTOM_ACTION_VALIDATION,
+                    error : { type: EmbedErrorCodes.CUSTOM_ACTION_VALIDATION, message: customActionsResult.errors }
+                });
         }
         const baseInitData = {
             customisations: getCustomisations(this.embedConfig, this.viewConfig),
@@ -658,12 +670,22 @@ export class TsEmbed {
         };
 
         if (Array.isArray(visibleActions) && Array.isArray(hiddenActions)) {
-            this.handleError('You cannot have both hidden actions and visible actions');
+            this.handleError({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_ACTIONS_CONFIG,
+                error : ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+            });
             return queryParams;
         }
 
         if (Array.isArray(visibleTabs) && Array.isArray(hiddenTabs)) {
-            this.handleError('You cannot have both hidden Tabs and visible Tabs');
+            this.handleError({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_TABS_CONFIG,
+                error : ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+            });
             return queryParams;
         }
         if (primaryAction) {
@@ -916,7 +938,12 @@ export class TsEmbed {
                         error: JSON.stringify(error),
                     });
                     this.handleInsertionIntoDOM(this.embedConfig.loginFailedMessage);
-                    this.handleError(error);
+                    this.handleError({
+                        errorType: ErrorDetailsTypes.API,
+                        message: error.message || ERROR_MESSAGE.LOGIN_FAILED,
+                        code: EmbedErrorCodes.LOGIN_FAILED,
+                        error : error,
+                    });
                 });
         });
     }
@@ -1323,12 +1350,22 @@ export class TsEmbed {
         uploadMixpanelEvent(`${MIXPANEL_EVENT.VISUAL_SDK_TRIGGER}-${messageType}`);
 
         if (!this.isRendered) {
-            this.handleError('Please call render before triggering events');
+            this.handleError({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.RENDER_BEFORE_EVENTS_REQUIRED,
+                code: EmbedErrorCodes.RENDER_NOT_CALLED,
+                error: ERROR_MESSAGE.RENDER_BEFORE_EVENTS_REQUIRED,
+            });
             return null;
         }
 
         if (!messageType) {
-            this.handleError('Host event type is undefined');
+            this.handleError({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.HOST_EVENT_TYPE_UNDEFINED,
+                code: EmbedErrorCodes.HOST_EVENT_TYPE_UNDEFINED,
+                error: ERROR_MESSAGE.HOST_EVENT_TYPE_UNDEFINED,
+            });
             return null;
         }
 

package/src/errors.ts

@@ -20,6 +20,13 @@ export const ERROR_MESSAGE = {
     RENDER_CALLED_BEFORE_INIT: 'Looks like render was called before calling init, the render won\'t start until init is called.\nFor more info check\n1. https://developers.thoughtspot.com/docs/Function_init#_init\n2.https://developers.thoughtspot.com/docs/getting-started#initSdk',
     SPOTTER_AGENT_NOT_INITIALIZED: 'SpotterAgent not initialized',
     OFFLINE_WARNING : 'Network not Detected. Embed is offline. Please reconnect and refresh',
+    INIT_SDK_REQUIRED: 'You need to init the ThoughtSpot SDK module first',
+    CONFLICTING_ACTIONS_CONFIG: 'You cannot have both hidden actions and visible actions',
+    CONFLICTING_TABS_CONFIG: 'You cannot have both hidden Tabs and visible Tabs',
+    RENDER_BEFORE_EVENTS_REQUIRED: 'Please call render before triggering events',
+    HOST_EVENT_TYPE_UNDEFINED: 'Host event type is undefined',
+    LOGIN_FAILED: 'Login failed',
+    ERROR_PARSING_API_INTERCEPT_BODY: 'Error parsing api intercept body',
 };
 
 export const CUSTOM_ACTIONS_ERROR_MESSAGE = {

package/src/index.ts

@@ -26,6 +26,7 @@ import {
     exportTML,
     executeTMLInput,
     exportTMLInput,
+    reloadIframe,
 } from './embed/base';
 import { PinboardEmbed, LiveboardViewConfig, LiveboardEmbed } from './embed/liveboard';
 import { SearchEmbed, SearchViewConfig } from './embed/search';
@@ -83,6 +84,7 @@ export {
     executeTML,
     exportTML,
     executeTMLInput,
+    reloadIframe,
     exportTMLInput,
     getEmbedConfig as getInitConfig,
     getSessionInfo,

package/src/react/all-types-export.ts

@@ -22,6 +22,7 @@ export {
     init,
     logout,
     prefetch,
+    reloadIframe,
     getInitConfig,
     getSessionInfo,
     uploadMixpanelEvent,