@thoughtspot/visual-embed-sdk 1.44.2 → 1.44.4-HE-beta.1

package/src/embed/hostEventClient/host-event-client.ts

@@ -1,4 +1,4 @@
-import { HostEvent } from '../../types';
+import { ContextType, HostEvent } from '../../types';
 import { processTrigger as processTriggerService } from '../../utils/processTrigger';
 import { getEmbedConfig } from '../embedConfig';
 import {
@@ -23,7 +23,7 @@ export class HostEventClient {
    * @param {any} data Data to send with the host event
    * @returns {Promise<any>} - the response from the process trigger
    */
-  protected async processTrigger(message: HostEvent, data: any): Promise<any> {
+  protected async processTrigger(message: HostEvent, data: any, context?: ContextType): Promise<any> {
       if (!this.iFrame) {
           throw new Error('Iframe element is not set');
       }
@@ -34,14 +34,16 @@ export class HostEventClient {
           message,
           thoughtspotHost,
           data,
+          context,
       );
   }
 
   public async handleHostEventWithParam<UIPassthroughEventT extends UIPassthroughEvent>(
       apiName: UIPassthroughEventT,
       parameters: UIPassthroughRequest<UIPassthroughEventT>,
+      context?: ContextType,
   ): Promise<UIPassthroughResponse<UIPassthroughEventT>> {
-      const response = (await this.triggerUIPassthroughApi(apiName, parameters))
+      const response = (await this.triggerUIPassthroughApi(apiName, parameters, context as ContextType))
           ?.filter?.((r) => r.error || r.value)[0];
 
       if (!response) {
@@ -65,8 +67,9 @@ export class HostEventClient {
   public async hostEventFallback(
       hostEvent: HostEvent,
       data: any,
+      context?: ContextType,
   ): Promise<any> {
-      return this.processTrigger(hostEvent, data);
+      return this.processTrigger(hostEvent, data, context);
   }
 
   /**
@@ -80,20 +83,22 @@ export class HostEventClient {
   public async triggerUIPassthroughApi<UIPassthroughEventT extends UIPassthroughEvent>(
       apiName: UIPassthroughEventT,
       parameters: UIPassthroughRequest<UIPassthroughEventT>,
+      context?: ContextType,
   ): Promise<UIPassthroughArrayResponse<UIPassthroughEventT>> {
       const res = await this.processTrigger(HostEvent.UIPassthrough, {
           type: apiName,
           parameters,
-      });
+      }, context);
 
       return res;
   }
 
   protected async handlePinEvent(
       payload: HostEventRequest<HostEvent.Pin>,
-  ): Promise<HostEventResponse<HostEvent.Pin>> {
+      context?: ContextType,
+  ): Promise<HostEventResponse<HostEvent.Pin, ContextType>> {
       if (!payload || !('newVizName' in payload)) {
-          return this.hostEventFallback(HostEvent.Pin, payload);
+          return this.hostEventFallback(HostEvent.Pin, payload, context);
       }
 
       const formattedPayload = {
@@ -104,6 +109,7 @@ export class HostEventClient {
 
       const data = await this.handleHostEventWithParam(
           UIPassthroughEvent.PinAnswerToLiveboard, formattedPayload,
+          context as ContextType,
       );
 
       return {
@@ -114,14 +120,16 @@ export class HostEventClient {
 
   protected async handleSaveAnswerEvent(
       payload: HostEventRequest<HostEvent.SaveAnswer>,
+      context?: ContextType,
   ): Promise<any> {
       if (!payload || !('name' in payload) || !('description' in payload)) {
           // Save is the fallback for SaveAnswer
-          return this.hostEventFallback(HostEvent.Save, payload);
+          return this.hostEventFallback(HostEvent.Save, payload, context);
       }
 
       const data = await this.handleHostEventWithParam(
           UIPassthroughEvent.SaveAnswer, payload,
+          context as ContextType,
       );
       return {
           ...data,
@@ -132,19 +140,22 @@ export class HostEventClient {
   public async triggerHostEvent<
     HostEventT extends HostEvent,
     PayloadT,
+    ContextT extends ContextType,
   >(
       hostEvent: HostEventT,
       payload?: TriggerPayload<PayloadT, HostEventT>,
-  ): Promise<TriggerResponse<PayloadT, HostEventT>> {
+      context?: ContextT,
+  ): Promise<TriggerResponse<PayloadT, HostEventT, ContextType>> {
       switch (hostEvent) {
           case HostEvent.Pin:
-              return this.handlePinEvent(payload as HostEventRequest<HostEvent.Pin>) as any;
+              return this.handlePinEvent(payload as HostEventRequest<HostEvent.Pin>, context as ContextType) as any;
           case HostEvent.SaveAnswer:
               return this.handleSaveAnswerEvent(
                   payload as HostEventRequest<HostEvent.SaveAnswer>,
+                  context as ContextType,
               ) as any;
           default:
-              return this.hostEventFallback(hostEvent, payload);
+              return this.hostEventFallback(hostEvent, payload, context);
       }
   }
 }

package/src/embed/liveboard.spec.ts

@@ -1495,7 +1495,7 @@ describe('Liveboard/viz embed tests', () => {
                 await liveboardEmbed.trigger(HostEvent.Save);
                 expect(mockProcessTrigger).toHaveBeenCalledWith(HostEvent.Save, {
                     vizId: 'testViz',
-                });
+                }, undefined);
             });
         });
     });

package/src/embed/liveboard.ts

@@ -22,12 +22,13 @@ import {
     LiveboardAppEmbedViewConfig,
     ErrorDetailsTypes,
     EmbedErrorCodes,
+    ContextType,
 } from '../types';
 import { calculateVisibleElementData, getQueryParamString, isUndefined, isValidCssMargin } from '../utils';
 import { getAuthPromise } from './base';
 import { TsEmbed, V1Embed } from './ts-embed';
 import { addPreviewStylesIfNotPresent } from '../utils/global-styles';
-import { TriggerPayload, TriggerResponse } from './hostEventClient/contracts';
+import { TriggerPayload, TriggerResponse, PageContextOptions } from './hostEventClient/contracts';
 import { logger } from '../utils/logger';
 
 
@@ -83,7 +84,7 @@ export interface LiveboardViewConfig extends BaseViewConfig, LiveboardOtherViewC
      * 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
+     * @version SDK: 1.44.2 | ThoughtSpot: 10.15.0.cl
      * @default 500
      * @example
      * ```js
@@ -642,6 +643,7 @@ export class LiveboardEmbed extends V1Embed {
     }
 
     private sendFullHeightLazyLoadData = () => {
+        console.log('sendFullHeightLazyLoadData', this.iFrame);
         const data = calculateVisibleElementData(this.iFrame);
         this.trigger(HostEvent.VisibleEmbedCoordinates, data);
     }
@@ -800,10 +802,11 @@ export class LiveboardEmbed extends V1Embed {
      * @param {any} data The payload to send with the message
      * @returns A promise that resolves with the response from the embedded app
      */
-    public trigger<HostEventT extends HostEvent, PayloadT>(
+    public trigger<HostEventT extends HostEvent, PayloadT, ContextT extends ContextType>(
         messageType: HostEventT,
         data: TriggerPayload<PayloadT, HostEventT> = ({} as any),
-    ): Promise<TriggerResponse<PayloadT, HostEventT>> {
+        context?: ContextT,
+    ): Promise<TriggerResponse<PayloadT, HostEventT, ContextT>> {
         const dataWithVizId: any = data;
         if (messageType === HostEvent.SetActiveTab) {
             this.setActiveTab(data as { tabId: string });
@@ -812,7 +815,7 @@ export class LiveboardEmbed extends V1Embed {
         if (typeof dataWithVizId === 'object' && this.viewConfig.vizId) {
             dataWithVizId.vizId = this.viewConfig.vizId;
         }
-        return super.trigger(messageType, dataWithVizId);
+        return super.trigger(messageType, dataWithVizId, context);
     }
     /**
      * Destroys the ThoughtSpot embed, and remove any nodes from the DOM.
@@ -889,6 +892,16 @@ export class LiveboardEmbed extends V1Embed {
 
         return url;
     }
+
+    /**
+     * Get the current context of the embedded liveboard.
+     * @returns The current context object containing the page type and object ids.
+     * @version SDK: 1.46.0 | ThoughtSpot: 26.3.0.cl
+     */
+    public async getCurrentContext(): Promise<PageContextOptions> {
+        const context = await super.getCurrentContext();
+        return context;
+    } 
 }
 
 /**

package/src/embed/sage.ts

@@ -6,6 +6,7 @@
  * @author Mourya Balabhadra <mourya.balabhadra@thoughtspot.com>
  */
 
+import { PageContextOptions } from './hostEventClient/contracts';
 import { DOMSelector, Param, BaseViewConfig, SearchLiveboardCommonViewConfig } from '../types';
 import { getQueryParamString } from '../utils';
 import { V1Embed } from './ts-embed';
@@ -229,4 +230,14 @@ export class SageEmbed extends V1Embed {
 
         return this;
     }
+
+    /**
+     * Get the current context of the embedded SageEmbed.
+     * @returns The current context object containing the page type and object ids.
+     * @version SDK: 1.46.0 | ThoughtSpot: 26.3.0.cl
+     */
+    public async getCurrentContext(): Promise<PageContextOptions> {
+        const context = await super.getCurrentContext();
+        return context;
+    }
 }

package/src/embed/search-bar.tsx

@@ -2,6 +2,7 @@ import { SearchLiveboardCommonViewConfig, BaseViewConfig, DefaultAppInitData, Pa
 import { getQueryParamString } from '../utils';
 import { TsEmbed } from './ts-embed';
 import { SearchOptions } from './search';
+import { PageContextOptions } from './hostEventClient/contracts';
 
 /**
  * @group Embed components
@@ -198,4 +199,14 @@ export class SearchBarEmbed extends TsEmbed {
         const defaultAppInitData = await super.getAppInitData();
         return { ...defaultAppInitData, ...this.getSearchInitData() };
     }
+
+    /**
+     * Get the current context of the embedded search bar.
+     * @returns The current context object containing the page type and object ids.
+     * @version SDK: 1.46.0 | ThoughtSpot: 26.3.0.cl
+     */
+    public async getCurrentContext(): Promise<PageContextOptions> {
+        const context = await super.getCurrentContext();
+        return context;
+    }
 }

package/src/embed/search.ts

@@ -27,6 +27,7 @@ import { getAuthPromise } from './base';
 import { getReleaseVersion } from '../auth';
 import { getEmbedConfig } from './embedConfig';
 import { getInterceptInitData } from '../api-intercept';
+import { PageContextOptions } from './hostEventClient/contracts';
 
 /**
  * Configuration for search options.
@@ -523,4 +524,14 @@ export class SearchEmbed extends TsEmbed {
         });
         return this;
     }
+
+    /**
+     * Get the current context of the embedded search.
+     * @returns The current context object containing the page type and object ids.
+     * @version SDK: 1.46.0 | ThoughtSpot: 26.3.0.cl
+     */
+    public async getCurrentContext(): Promise<PageContextOptions> {
+        const context = await super.getCurrentContext();
+        return context;
+    }
 }

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

@@ -204,6 +204,7 @@ describe('Unit test case for ts embed', () => {
                         parameters: payload,
                         type: UIPassthroughEvent.PinAnswerToLiveboard,
                     },
+                    undefined,
                 );
             });
         });
@@ -224,6 +225,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.Save,
                     'http://tshost',
                     {},
+                    undefined,
                 );
             });
         });
@@ -245,6 +247,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.Save,
                     'http://tshost',
                     false,
+                    undefined,
                 );
             });
         });
@@ -1331,6 +1334,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1467,6 +1471,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1481,6 +1486,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1495,6 +1501,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1509,6 +1516,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -2483,6 +2491,44 @@ describe('Unit test case for ts embed', () => {
             expect(libEmbed.preRender).toHaveBeenCalledTimes(0);
         });
 
+        it('should set overflow:hidden when hidePreRender and remove when showPreRender', async () => {
+            createRootEleForEmbed();
+
+            (window as any).ResizeObserver = window.ResizeObserver
+                || jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: jest.fn(),
+                    unobserve: jest.fn(),
+                }));
+
+            const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                preRenderId: 'overflow-test',
+                liveboardId: 'myLiveboardId',
+            });
+
+            await libEmbed.preRender();
+            await waitFor(() => !!getIFrameEl());
+
+            const preRenderIds = libEmbed.getPreRenderIds();
+            const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
+
+            // After preRender (calls hidePreRender by default)
+            // should have overflow:hidden
+            expect(preRenderWrapper.style.overflow).toBe('hidden');
+            expect(preRenderWrapper.style.opacity).toBe('0');
+
+            // After showPreRender, overflow should be removed
+            // to inherit from CSS
+            libEmbed.showPreRender();
+            expect(preRenderWrapper.style.overflow).toBe('');
+            expect(preRenderWrapper.style.opacity).toBe('');
+
+            // After hidePreRender again, overflow should be hidden
+            libEmbed.hidePreRender();
+            expect(preRenderWrapper.style.overflow).toBe('hidden');
+            expect(preRenderWrapper.style.opacity).toBe('0');
+        });
+
         it('it should connect with another object', async () => {
             createRootEleForEmbed();
             mockMessageChannel();
@@ -4017,7 +4063,7 @@ describe('Destroy error handling', () => {
         }).not.toThrow();
         
         expect(logSpy).toHaveBeenCalledWith('Error destroying TS Embed', expect.any(Error));
-        logSpy.mockRestore();
+        logSpy.mockReset();
     });
 });
 
@@ -4060,11 +4106,12 @@ describe('Fullscreen change handler behavior', () => {
         document.dispatchEvent(event);
         
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
                 expect.any(Object),
                 HostEvent.ExitPresentMode,
                 expect.any(String),
                 expect.any(Object),
+                undefined,
             );
         });
     });
@@ -4107,19 +4154,7 @@ describe('Fullscreen change handler behavior', () => {
 });
 
 describe('ShowPreRender with UpdateEmbedParams', () => {
-    beforeAll(() => {
-        init({
-            thoughtSpotHost: 'tshost',
-            authType: AuthType.None,
-        });
-    });
-
-    afterEach(() => {
-        const rootEle = document.getElementById('myRoot');
-        rootEle?.remove();
-    });
-
-    test('should trigger UpdateEmbedParams when showPreRender connects to existing prerendered component', async () => {
+    const setupPreRenderTest = async (preRenderId: string, initialConfig: Partial<LiveboardViewConfig>) => {
         createRootEleForEmbed();
         mockMessageChannel();
 
@@ -4131,8 +4166,8 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
             }));
 
         const embed1 = new LiveboardEmbed('#tsEmbedDiv', {
-            preRenderId: 'update-params-test',
-            liveboardId: 'original-lb',
+            preRenderId,
+            ...initialConfig,
         });
         
         await embed1.preRender();
@@ -4143,6 +4178,24 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         mockProcessTrigger.mockClear();
         mockProcessTrigger.mockResolvedValue({});
 
+        return embed1;
+    };
+
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+        });
+    });
+
+    afterEach(() => {
+        const rootEle = document.getElementById('myRoot');
+        rootEle?.remove();
+    });
+
+    test('should trigger UpdateEmbedParams when showPreRender connects to existing prerendered component', async () => {
+        await setupPreRenderTest('update-params-test', { liveboardId: 'original-lb' });
+
         const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
             preRenderId: 'update-params-test',
             liveboardId: 'updated-lb',
@@ -4151,14 +4204,148 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         embed2.showPreRender();
 
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
                 expect.any(Object),
                 HostEvent.UpdateEmbedParams,
                 expect.any(String),
                 expect.objectContaining({
                     liveboardId: 'updated-lb',
                 }),
+                undefined,
             );
         });
     });
+
+    test('should trigger UpdateEmbedParams with runtime filters and visible vizs', async () => {
+        await setupPreRenderTest('url-param-test', { liveboardId: 'original-lb' });
+
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'url-param-test',
+            liveboardId: 'original-lb',
+            visibleVizs: ['viz-1'],
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red', 'blue'],
+                },
+                {
+                    columnName: 'Region',
+                    operator: RuntimeFilterOp.EQ,
+                    values: ['North'],
+                },
+            ],
+        });
+
+        embed2.showPreRender();
+
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
+                expect.any(Object),
+                HostEvent.UpdateEmbedParams,
+                expect.any(String),
+                expect.objectContaining({
+                    liveboardId: 'original-lb',
+                    visibleVizs: ['viz-1'],
+                    runtimeFilters: [
+                        {
+                            columnName: 'Color',
+                            operator: RuntimeFilterOp.IN,
+                            values: ['red', 'blue'],
+                        },
+                        {
+                            columnName: 'Region',
+                            operator: RuntimeFilterOp.EQ,
+                            values: ['North'],
+                        },
+                    ],
+                }),
+                undefined,
+            );
+        });
+    });
+
+    test('should trigger UpdateEmbedParams with updated config', async () => {
+        await setupPreRenderTest('preserve-config-test', {
+            liveboardId: 'original-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red', 'blue'],
+                },
+            ],
+        });
+
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'preserve-config-test',
+            liveboardId: 'original-lb',
+            visibleVizs: ['viz-1', 'viz-2'],
+            runtimeFilters: [
+                {
+                    columnName: 'Region',
+                    operator: RuntimeFilterOp.EQ,
+                    values: ['North'],
+                },
+            ],
+        });
+
+        embed2.showPreRender();
+
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
+                expect.any(Object),
+                HostEvent.UpdateEmbedParams,
+                expect.any(String),
+                expect.objectContaining({
+                    liveboardId: 'original-lb',
+                    visibleVizs: ['viz-1', 'viz-2'],
+                    runtimeFilters: [
+                        {
+                            columnName: 'Region',
+                            operator: RuntimeFilterOp.EQ,
+                            values: ['North'],
+                        },
+                    ],
+                }),
+                undefined,
+            );
+        });
+    });
+
+    test('should handle error when getUpdateEmbedParamsObject fails during showPreRender', async () => {
+        await setupPreRenderTest('error-test', { liveboardId: 'original-lb' });
+
+        const handleErrorSpy = jest.spyOn(LiveboardEmbed.prototype as any, 'handleError');
+
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'error-test',
+            liveboardId: 'updated-lb',
+        });
+
+        const mockError = new Error('Failed to get params');
+        jest.spyOn(embed2 as any, 'getUpdateEmbedParamsObject').mockRejectedValue(mockError);
+
+        embed2.showPreRender();
+
+        await executeAfterWait(() => {
+            expect(handleErrorSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    errorType: ErrorDetailsTypes.API,
+                    message: 'Failed to get params',
+                    code: EmbedErrorCodes.UPDATE_PARAMS_FAILED,
+                    error: 'Failed to get params',
+                }),
+            );
+
+            expect(mockProcessTrigger).not.toHaveBeenCalledWith(
+                expect.any(Object),
+                HostEvent.UpdateEmbedParams,
+                expect.any(String),
+                expect.any(Object),
+            );
+        });
+
+        handleErrorSpy.mockRestore();
+    });
 });