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

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();
+    });
 });

package/src/embed/ts-embed.ts

@@ -60,6 +60,7 @@ import {
     EmbedErrorDetailsEvent,
     ErrorDetailsTypes,
     EmbedErrorCodes,
+    ContextType,
 } from '../types';
 import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
 import { processEventData, processAuthFailure } from '../utils/processData';
@@ -75,6 +76,7 @@ import { ERROR_MESSAGE } from '../errors';
 import { getPreauthInfo } from '../utils/sessionInfoService';
 import { HostEventClient } from './hostEventClient/host-event-client';
 import { getInterceptInitData, handleInterceptEvent, processApiInterceptResponse, processLegacyInterceptResponse } from '../api-intercept';
+import { getHostEventsConfig } from '../utils';
 
 const { version } = pkgInfo;
 
@@ -480,6 +482,7 @@ export class TsEmbed {
             hiddenListColumns: this.viewConfig.hiddenListColumns || [],
             customActions: customActionsResult.actions,
             ...getInterceptInitData(this.viewConfig),
+            ...getHostEventsConfig(this.viewConfig),
         };
 
         return baseInitData;
@@ -592,9 +595,11 @@ export class TsEmbed {
         return `${basePath}#`;
     }
 
-    protected getUpdateEmbedParamsObject() {
+    protected async getUpdateEmbedParamsObject() {
         let queryParams = this.getEmbedParamsObject();
-        queryParams = { ...this.viewConfig, ...queryParams, ...this.getAppInitData() };
+        const appInitData = await this.getAppInitData();
+        queryParams = { ...this.viewConfig, ...queryParams, ...appInitData };
+        
         return queryParams;
     }
 
@@ -957,6 +962,8 @@ export class TsEmbed {
         preRenderWrapper.id = preRenderIds.wrapper;
         const initialPreRenderWrapperStyle = {
             position: 'absolute',
+            top: '0',
+            left: '0',
             width: '100vw',
             height: '100vh',
         };
@@ -1343,10 +1350,11 @@ export class TsEmbed {
      * @param {any} data The payload to send with the message
      * @returns A promise that resolves with the response from the embedded app
      */
-    public async trigger<HostEventT extends HostEvent, PayloadT>(
+    public async 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>> {
         uploadMixpanelEvent(`${MIXPANEL_EVENT.VISUAL_SDK_TRIGGER}-${messageType}`);
 
         if (!this.isRendered) {
@@ -1379,7 +1387,7 @@ export class TsEmbed {
         }
 
         // send an empty object, this is needed for liveboard default handlers
-        return this.hostEventClient.triggerHostEvent(messageType, data);
+        return this.hostEventClient.triggerHostEvent(messageType, data, context);
     }
 
     /**
@@ -1421,6 +1429,20 @@ export class TsEmbed {
         return this.render();
     }
 
+    /**
+     * Get the current context of the embedded TS component.
+     * @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<any> {
+        return new Promise((resolve) => {
+            this.executeAfterEmbedContainerLoaded(async () => {
+                const context = await this.trigger(HostEvent.GetPageContext, {});
+                resolve(context);
+            });
+        });
+    }
+
     /**
      * Creates the preRender shell
      * @param showPreRenderByDefault - Show the preRender after render, hidden by default
@@ -1574,8 +1596,19 @@ export class TsEmbed {
             }
             this.validatePreRenderViewConfig(this.viewConfig);
             logger.debug('triggering UpdateEmbedParams', this.viewConfig);
-            this.executeAfterEmbedContainerLoaded(() => {
-                this.trigger(HostEvent.UpdateEmbedParams, this.getUpdateEmbedParamsObject());
+            this.executeAfterEmbedContainerLoaded(async () => {
+                try {
+                    const params = await this.getUpdateEmbedParamsObject();
+                    this.trigger(HostEvent.UpdateEmbedParams, params);
+                } catch (error) {
+                    logger.error(ERROR_MESSAGE.UPDATE_PARAMS_FAILED, error);
+                    this.handleError({
+                        errorType: ErrorDetailsTypes.API,
+                        message: error?.message || ERROR_MESSAGE.UPDATE_PARAMS_FAILED,
+                        code: EmbedErrorCodes.UPDATE_PARAMS_FAILED,
+                        error: error?.message || error,
+                    });
+                }
             });
         }
 
@@ -1598,7 +1631,7 @@ export class TsEmbed {
             }
         }
 
-        removeStyleProperties(this.preRenderWrapper, ['z-index', 'opacity', 'pointer-events']);
+        removeStyleProperties(this.preRenderWrapper, ['z-index', 'opacity', 'pointer-events', 'overflow']);
 
         this.subscribeToEvents();
 
@@ -1647,7 +1680,10 @@ export class TsEmbed {
             opacity: '0',
             pointerEvents: 'none',
             zIndex: '-1000',
-            position: 'absolute ',
+            position: 'absolute',
+            top: '0',
+            left: '0',
+            overflow: 'hidden',
         };
         setStyleProperties(this.preRenderWrapper, preRenderHideStyles);
 

package/src/errors.ts

@@ -28,6 +28,7 @@ export const ERROR_MESSAGE = {
     LOGIN_FAILED: 'Login failed',
     ERROR_PARSING_API_INTERCEPT_BODY: 'Error parsing api intercept body',
     SSR_ENVIRONMENT_ERROR: 'SSR environment detected. This function cannot be called in SSR environment.',
+    UPDATE_PARAMS_FAILED: 'Failed to update embed parameters',
 };
 
 export const CUSTOM_ACTIONS_ERROR_MESSAGE = {

package/src/index.ts

@@ -66,6 +66,9 @@ import {
     CustomActionsPosition,
     CustomActionTarget,
     InterceptedApiType,
+    EmbedErrorCodes,
+    ErrorDetailsTypes,
+    ContextType,
 } from './types';
 import { CustomCssVariables } from './css-variables';
 import { SageEmbed, SageViewConfig } from './embed/sage';
@@ -119,6 +122,7 @@ export {
     RuntimeFilterOp,
     EmbedEvent,
     HostEvent,
+    ContextType,
     DataSourceVisualMode,
     Action,
     ContextMenuTriggerOptions,
@@ -156,6 +160,8 @@ export {
     CustomActionsPosition,
     CustomActionTarget,
     InterceptedApiType,
+    EmbedErrorCodes,
+    ErrorDetailsTypes,
 };
 
 export { resetCachedAuthToken } from './authToken';