@thoughtspot/visual-embed-sdk 1.41.1 → 1.42.1-alpha.1

package/src/embed/hostEventClient/contracts.ts

@@ -7,6 +7,7 @@ export enum UIPassthroughEvent {
   GetAvailableUIPassthroughs = 'getAvailableUiPassthroughs',
   GetAnswerConfig = 'getAnswerPageConfig',
   GetLiveboardConfig = 'getPinboardPageConfig',
+  GetUnsavedAnswerTML = 'getUnsavedAnswerTML',
 }
 
 // UI Passthrough Contract
@@ -63,6 +64,15 @@ export type UIPassthroughContractBase = {
     request: any;
     response: any;
   };
+  [UIPassthroughEvent.GetUnsavedAnswerTML]: {
+    request: {
+      sessionId?: string;
+      vizId?: string;
+    };
+    response: {
+      tml: string;
+    };
+  };
 };
 
 // UI Passthrough Request and Response

package/src/embed/liveboard.spec.ts

@@ -183,6 +183,36 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should set isLinkParametersEnabled to true in url', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            isLinkParametersEnabled: true,
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isLinkParametersEnabled=true${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
+    test('should set isLinkParametersEnabled to false in url', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            isLinkParametersEnabled: false,
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isLinkParametersEnabled=false${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
     test('should set visible actions as empty array', async () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             visibleActions: [],
@@ -657,6 +687,7 @@ describe('Liveboard/viz embed tests', () => {
     test('navigateToLiveboard should trigger the navigate event with the correct path', async (done) => {
         mockMessageChannel();
         // mock getSessionInfo
+
         mockGetSessionInfo();
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             ...defaultViewConfig,
@@ -684,6 +715,13 @@ describe('Liveboard/viz embed tests', () => {
         mockMessageChannel();
 
         // mock getSessionInfo
+        jest.spyOn(SessionInfoService, 'getSessionInfo').mockResolvedValue({
+            releaseVersion: '1.0.0',
+            userGUID: '1234567890',
+            currentOrgId: 1,
+            privileges: [],
+            mixpanelToken: '1234567890',
+        });
         mockGetSessionInfo();
 
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -779,6 +817,12 @@ describe('Liveboard/viz embed tests', () => {
     });
 
     describe('PreRender flow for liveboard embed', () => {
+        beforeAll(() => {
+            init({
+                thoughtSpotHost: "http://tshost",
+                authType: AuthType.None,
+            });
+        });
         test('it should preRender generic with liveboard id is not passed', async (done) => {
             const consoleSpy = jest.spyOn(console, 'error');
             const libEmbed = new LiveboardEmbed(getRootEl(), {

package/src/embed/liveboard.ts

@@ -440,6 +440,12 @@ export class LiveboardEmbed extends V1Embed {
      * embedded Liveboard or visualization.
      */
     protected getEmbedParams() {
+        const params = this.getEmbedParamsObject();
+        const queryParams = getQueryParamString(params, true);
+        return queryParams;
+    }
+
+    protected getEmbedParamsObject() {
         let params: any = {};
         params = this.getBaseQueryParams(params);
         const {
@@ -471,6 +477,7 @@ export class LiveboardEmbed extends V1Embed {
             isLiveboardStylingAndGroupingEnabled,
             isPNGInScheduledEmailsEnabled = false,
             showSpotterLimitations,
+            isLinkParametersEnabled,
         } = this.viewConfig;
 
         const preventLiveboardFilterRemoval = this.viewConfig.preventLiveboardFilterRemoval
@@ -546,6 +553,10 @@ export class LiveboardEmbed extends V1Embed {
             params[Param.ShowSpotterLimitations] = showSpotterLimitations;
         }
 
+        if (isLinkParametersEnabled !== undefined) {
+            params[Param.isLinkParametersEnabled] = isLinkParametersEnabled;
+        }
+
         params[Param.LiveboardHeaderSticky] = isLiveboardHeaderSticky;
         params[Param.LiveboardHeaderV2] = isLiveboardCompactHeaderEnabled;
         params[Param.ShowLiveboardVerifiedBadge] = showLiveboardVerifiedBadge;
@@ -557,7 +568,7 @@ export class LiveboardEmbed extends V1Embed {
         params[Param.LiveboardXLSXCSVDownload] = !!liveboardXLSXCSVDownload;
         const queryParams = getQueryParamString(params, true);
 
-        return queryParams;
+        return params;
     }
 
     private getIframeSuffixSrc(liveboardId: string, vizId: string, activeTabId: string) {

package/src/embed/sage.ts

@@ -153,12 +153,7 @@ export class SageEmbed extends V1Embed {
         super(domSelector, viewConfig);
     }
 
-    /**
-     * Constructs a map of parameters to be passed on to the
-     * embedded Eureka or Sage search page.
-     * @returns {string} query string
-     */
-    protected getEmbedParams(): string {
+    protected getEmbedParamsObject() {
         const {
             disableWorksheetChange,
             hideWorksheetSelector,
@@ -184,6 +179,16 @@ export class SageEmbed extends V1Embed {
         params[Param.IsProductTour] = !!isProductTour;
         params[Param.HideSageAnswerHeader] = !!hideSageAnswerHeader;
 
+        return params;
+    }
+
+    /**
+     * Constructs a map of parameters to be passed on to the
+     * embedded Eureka or Sage search page.
+     * @returns {string} query string
+     */
+    protected getEmbedParams(): string {
+        const params = this.getEmbedParamsObject();
         return getQueryParamString(params, true);
     }
 
@@ -194,15 +199,15 @@ export class SageEmbed extends V1Embed {
      */
     public getIFrameSrc(): string {
         const path = 'eureka';
-        const postHashObj = {};
+        const postHashObj: Record<string, any> = {};
         const tsPostHashParams = this.getThoughtSpotPostUrlParams();
         const {
             dataSource, searchOptions,
         } = this.viewConfig;
 
-        if (dataSource) postHashObj[Param.WorksheetId] = dataSource;
+        if (dataSource) (postHashObj as any)[Param.WorksheetId] = dataSource;
         if (searchOptions?.searchQuery && searchOptions.executeSearch) {
-            postHashObj[Param.executeSearch] = true;
+            (postHashObj as any)[Param.executeSearch] = true;
         }
 
         let sagePostHashParams = new URLSearchParams(postHashObj).toString();

package/src/embed/search-bar.tsx

@@ -118,12 +118,7 @@ export class SearchBarEmbed extends TsEmbed {
         this.viewConfig = viewConfig;
     }
 
-    /**
-     * Construct the URL of the embedded ThoughtSpot search to be
-     * loaded in the iframe
-     * @param dataSources A list of data source GUIDs
-     */
-    private getIFrameSrc() {
+    protected getEmbedParamsObject() {
         const {
             searchOptions,
             dataSource,
@@ -131,7 +126,6 @@ export class SearchBarEmbed extends TsEmbed {
             useLastSelectedSources = false,
             excludeSearchTokenStringFromURL,
         } = this.viewConfig;
-        const path = 'search-bar-embed';
         const queryParams = this.getBaseQueryParams();
 
         queryParams[Param.HideActions] = [...(queryParams[Param.HideActions] ?? [])];
@@ -159,6 +153,19 @@ export class SearchBarEmbed extends TsEmbed {
             queryParams[Param.UseLastSelectedDataSource] = false;
         }
         queryParams[Param.searchEmbed] = true;
+
+        return queryParams;
+    }
+
+    /**
+     * Construct the URL of the embedded ThoughtSpot search to be
+     * loaded in the iframe
+     * @param dataSources A list of data source GUIDs
+     */
+    private getIFrameSrc() {
+        const queryParams = this.getEmbedParamsObject();
+        const path = 'search-bar-embed';
+       
         let query = '';
         const queryParamsString = getQueryParamString(queryParams, true);
         if (queryParamsString) {

package/src/embed/search.ts

@@ -26,6 +26,7 @@ import { ERROR_MESSAGE } from '../errors';
 import { getAuthPromise } from './base';
 import { getReleaseVersion } from '../auth';
 import { getEmbedConfig } from './embedConfig';
+import { getInterceptInitData } from '../api-intercept';
 
 /**
  * Configuration for search options.
@@ -331,7 +332,7 @@ export const HiddenActionItemByDefaultForSearchEmbed = [
 ];
 
 export interface SearchAppInitData extends DefaultAppInitData {
-  searchOptions?: SearchOptions;
+    searchOptions?: SearchOptions;
 }
 
 /**
@@ -381,7 +382,7 @@ export class SearchEmbed extends TsEmbed {
         return { ...defaultAppInitData, ...this.getSearchInitData() };
     }
 
-    protected getEmbedParams(): string {
+    protected getEmbedParamsObject() {
         const {
             hideResults,
             enableSearchAssist,
@@ -398,7 +399,7 @@ export class SearchEmbed extends TsEmbed {
             collapseSearchBarInitially = false,
             enableCustomColumnGroups = false,
             isOnBeforeGetVizDataInterceptEnabled = false,
-            /* eslint-disable-next-line max-len */
+
             dataPanelCustomGroupsAccordionInitialState = DataPanelCustomColumnGroupsAccordionState.EXPAND_ALL,
             focusSearchBarOnRender = true,
             excludeRuntimeParametersfromURL,
@@ -442,8 +443,9 @@ export class SearchEmbed extends TsEmbed {
             queryParams[Param.HideSearchBar] = true;
         }
 
-        if (isOnBeforeGetVizDataInterceptEnabled) {
-            /* eslint-disable-next-line max-len */
+        const { enableApiIntercept } = getInterceptInitData(this.embedConfig, this.viewConfig);
+        if (isOnBeforeGetVizDataInterceptEnabled && !enableApiIntercept) {
+
             queryParams[Param.IsOnBeforeGetVizDataInterceptEnabled] = isOnBeforeGetVizDataInterceptEnabled;
         }
 
@@ -460,7 +462,7 @@ export class SearchEmbed extends TsEmbed {
         }
 
         queryParams[Param.searchEmbed] = true;
-        /* eslint-disable-next-line max-len */
+
         queryParams[Param.CollapseSearchBarInitially] = collapseSearchBarInitially || collapseSearchBar;
         queryParams[Param.EnableCustomColumnGroups] = enableCustomColumnGroups;
         if (dataPanelCustomGroupsAccordionInitialState
@@ -468,12 +470,23 @@ export class SearchEmbed extends TsEmbed {
             || dataPanelCustomGroupsAccordionInitialState
             === DataPanelCustomColumnGroupsAccordionState.EXPAND_FIRST
         ) {
-            /* eslint-disable-next-line max-len */
+
             queryParams[Param.DataPanelCustomGroupsAccordionInitialState] = dataPanelCustomGroupsAccordionInitialState;
         } else {
-            /* eslint-disable-next-line max-len */
+
             queryParams[Param.DataPanelCustomGroupsAccordionInitialState] = DataPanelCustomColumnGroupsAccordionState.EXPAND_ALL;
         }
+        return queryParams;
+    }
+
+    protected getEmbedParams() {
+        const {
+            runtimeParameters,
+            runtimeFilters,
+            excludeRuntimeParametersfromURL,
+            excludeRuntimeFiltersfromURL,
+        } = this.viewConfig;
+        const queryParams = this.getEmbedParamsObject();
         let query = '';
         const queryParamsString = getQueryParamString(queryParams, true);
         if (queryParamsString) {

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

@@ -1045,7 +1045,7 @@ describe('Unit test case for ts embed', () => {
                 type: EmbedEvent.APP_INIT,
                 data: {},
             };
-            
+
             // Create a SearchEmbed with valid custom actions to test
             // CustomActionsValidationResult
             const searchEmbed = new SearchEmbed(getRootEl(), {
@@ -1067,7 +1067,7 @@ describe('Unit test case for ts embed', () => {
                     }
                 ]
             });
-            
+
             searchEmbed.render();
             const mockPort: any = {
                 postMessage: jest.fn(),
@@ -1116,7 +1116,7 @@ describe('Unit test case for ts embed', () => {
                         customVariablesForThirdPartyTools: {},
                     },
                 });
-                
+
                 // Verify that CustomActionsValidationResult structure is
                 // correct
                 const appInitData = mockPort.postMessage.mock.calls[0][0].data;
@@ -1137,7 +1137,7 @@ describe('Unit test case for ts embed', () => {
                         })
                     ])
                 );
-                
+
                 // Verify actions are sorted by name (alphabetically)
                 expect(appInitData.customActions[0].name).toBe('Another Valid Action');
                 expect(appInitData.customActions[1].name).toBe('Valid Action');
@@ -2488,7 +2488,7 @@ describe('Unit test case for ts embed', () => {
         });
 
         afterAll((): void => {
-            window.location = location;
+            (window.location as any) = location;
         });
 
         it('get url params for TS', () => {
@@ -3345,4 +3345,115 @@ describe('Unit test case for ts embed', () => {
             expect(searchEmbed.isEmbedContainerLoaded).toBe(true);
         });
     });
+
+    describe('Online event listener registration after auth failure', () => {
+        beforeAll(() => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+                loginFailedMessage: 'Not logged in',
+            });
+        });
+
+        test('should register online event listener when authentication fails', async () => {
+            const addEventListenerSpy = jest.spyOn(window, 'addEventListener');
+            jest.spyOn(baseInstance, 'getAuthPromise').mockRejectedValueOnce(
+                new Error('Auth failed'),
+            );
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            addEventListenerSpy.mockClear();
+            await searchEmbed.render();
+            await executeAfterWait(() => {
+                expect(getRootEl().innerHTML).toContain('Not logged in');
+                const onlineListenerCalls = addEventListenerSpy.mock.calls.filter(
+                    (call) => call[0] === 'online',
+                );
+                expect(onlineListenerCalls).toHaveLength(1);
+                const offlineListenerCalls = addEventListenerSpy.mock.calls.filter(
+                    (call) => call[0] === 'offline',
+                );
+                expect(offlineListenerCalls).toHaveLength(1);
+                const messageListenerCalls = addEventListenerSpy.mock.calls.filter(
+                    (call) => call[0] === 'message',
+                );
+                expect(messageListenerCalls).toHaveLength(0);
+            });
+
+            addEventListenerSpy.mockRestore();
+        });
+
+        test('should attempt to trigger reload when online event occurs after auth failure', async () => {
+            jest.spyOn(baseInstance, 'getAuthPromise').mockRejectedValueOnce(
+                new Error('Auth failed'),
+            );
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            const triggerSpy = jest.spyOn(searchEmbed, 'trigger').mockResolvedValue(null);
+            await searchEmbed.render();
+
+            await executeAfterWait(() => {
+                expect(getRootEl().innerHTML).toContain('Not logged in');
+                triggerSpy.mockClear();
+                const onlineEvent = new Event('online');
+                window.dispatchEvent(onlineEvent);
+                expect(triggerSpy).toHaveBeenCalledWith(HostEvent.Reload);
+            });
+
+            triggerSpy.mockReset();
+        });
+
+        test('should handle online event gracefully when no iframe exists', async () => {
+            jest.spyOn(baseInstance, 'getAuthPromise').mockRejectedValueOnce(
+                new Error('Auth failed'),
+            );
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+            await searchEmbed.render();
+            await executeAfterWait(() => {
+                expect(getRootEl().innerHTML).toContain('Not logged in');
+                const onlineEvent = new Event('online');
+                expect(() => {
+                    window.dispatchEvent(onlineEvent);
+                }).not.toThrow();
+            });
+
+            errorSpy.mockReset();
+        });
+
+        test('should register all event listeners when authentication succeeds', async () => {
+            const addEventListenerSpy = jest.spyOn(window, 'addEventListener');
+            jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValueOnce(true);
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            addEventListenerSpy.mockClear();
+            await searchEmbed.render();
+            await executeAfterWait(() => {
+                const onlineListenerCalls = addEventListenerSpy.mock.calls.filter(
+                    (call) => call[0] === 'online',
+                );
+                expect(onlineListenerCalls).toHaveLength(1);
+                const offlineListenerCalls = addEventListenerSpy.mock.calls.filter(
+                    (call) => call[0] === 'offline',
+                );
+                expect(offlineListenerCalls).toHaveLength(1);
+                const messageListenerCalls = addEventListenerSpy.mock.calls.filter(
+                    (call) => call[0] === 'message',
+                );
+                expect(messageListenerCalls).toHaveLength(1);
+            });
+
+            addEventListenerSpy.mockRestore();
+        });
+        test('should successfully trigger reload when online event occurs after auth success', async () => {
+            jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValueOnce(true);
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            const triggerSpy = jest.spyOn(searchEmbed, 'trigger').mockResolvedValue({} as any);
+            await searchEmbed.render();
+            await executeAfterWait(() => {
+                triggerSpy.mockClear();
+                const onlineEvent = new Event('online');
+                window.dispatchEvent(onlineEvent);
+                expect(triggerSpy).toHaveBeenCalledWith(HostEvent.Reload);
+            });
+            triggerSpy.mockReset();
+        });
+    });
 });