@thoughtspot/visual-embed-sdk 1.46.3 → 1.46.5-beta.1

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

@@ -205,6 +205,128 @@ describe('HostEventClient', () => {
             expect(result).toEqual(mockResponse);
         });
 
+        it('should route GetAnswerSession through passthrough and return data', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const mockResponse = [{ value: { session: 'testSession', embedAnswerData: { id: '1' } } }];
+            mockProcessTrigger.mockResolvedValue(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.GetAnswerSession, parameters: { vizId: '123' } },
+                undefined,
+            );
+            expect(result).toEqual({ session: 'testSession', embedAnswerData: { id: '1' } });
+        });
+
+        it('should fall back to legacy host event when passthrough returns no data for GetAnswerSession', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce({ session: 'fallbackSession' });
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                expect.anything(),
+                HostEvent.GetAnswerSession,
+                mockThoughtSpotHost,
+                { vizId: '123' },
+                undefined,
+            );
+            expect(result).toEqual({ session: 'fallbackSession' });
+        });
+
+        it('should throw real errors from passthrough without falling back', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ error: 'Permission denied' }]);
+
+            await expect(client.triggerHostEvent(HostEvent.GetAnswerSession, {}))
+                .rejects.toThrow('Permission denied');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should route GetFilters through passthrough and return data', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const mockResponse = [{ value: { liveboardFilters: [{ id: 'f1' }], runtimeFilters: [] as any[] } }];
+            mockProcessTrigger.mockResolvedValue(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.GetFilters, parameters: {} },
+                undefined,
+            );
+            expect(result).toEqual({ liveboardFilters: [{ id: 'f1' }], runtimeFilters: [] });
+        });
+
+        it('should route GetTabs through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            const mockResponse = [{ value: { orderedTabIds: ['t1', 't2'], numberOfTabs: 2, Tabs: [] as any[] } }];
+            mockProcessTrigger.mockResolvedValue(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetTabs, {});
+
+            expect(result).toEqual({ orderedTabIds: ['t1', 't2'], numberOfTabs: 2, Tabs: [] });
+        });
+
+        it('should route GetTML through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            const tmlData = { answer: { search_query: 'revenue by region' } };
+            mockProcessTrigger.mockResolvedValue([{ value: tmlData }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetTML, {});
+
+            expect(result).toEqual(tmlData);
+        });
+
+        it('should route GetIframeUrl through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { iframeUrl: 'https://ts.example.com/embed' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetIframeUrl, {});
+
+            expect(result).toEqual({ iframeUrl: 'https://ts.example.com/embed' });
+        });
+
+        it('should route GetParameters through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { parameters: [{ name: 'p1' }] } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetParameters, {});
+
+            expect(result).toEqual({ parameters: [{ name: 'p1' }] });
+        });
+
+        it('should route getExportRequestForCurrentPinboard through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { v2Content: 'exportData' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.getExportRequestForCurrentPinboard, {});
+
+            expect(result).toEqual({ v2Content: 'exportData' });
+        });
+
+        it('should fall back to legacy for GetFilters when passthrough returns null', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce({ liveboardFilters: [], runtimeFilters: [] });
+
+            const result = await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual({ liveboardFilters: [], runtimeFilters: [] });
+        });
+
         it('should call fallback  for Pin event', async () => {
             const { client, mockIframe } = createHostEventClient();
             const hostEvent = HostEvent.Pin;
@@ -318,4 +440,139 @@ describe('HostEventClient', () => {
             });
         });
     });
+
+    describe('getDataWithPassthroughFallback', () => {
+        const callMethod = (client: HostEventClient, ...args: any[]) => (client as any).getDataWithPassthroughFallback(...args);
+
+        it('should return unwrapped value when passthrough succeeds', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { session: 's1', embedAnswerData: { id: 'a1' } } }]);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetAnswerSession, HostEvent.GetAnswerSession, { vizId: '1' },
+            );
+
+            expect(result).toEqual({ session: 's1', embedAnswerData: { id: 'a1' } });
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should fall back to legacy when passthrough returns empty array', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { session: 'legacy' };
+            mockProcessTrigger
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetAnswerSession, HostEvent.GetAnswerSession, { vizId: '1' },
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should fall back to legacy when passthrough returns null', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { parameters: [] as any[] };
+            mockProcessTrigger
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetParameters, HostEvent.GetParameters, {},
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should fall back to legacy when passthrough returns undefined', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { iframeUrl: 'https://ts.example.com' };
+            mockProcessTrigger
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetIframeUrl, HostEvent.GetIframeUrl, {},
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should fall back when response array has no matching entries', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { v2Content: 'data' };
+            mockProcessTrigger
+                .mockResolvedValueOnce([{ refId: 'r1' }])
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetExportRequestForCurrentPinboard,
+                HostEvent.getExportRequestForCurrentPinboard, {},
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should throw when response has error field', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ error: 'Permission denied' }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetFilters, HostEvent.GetFilters, {},
+            )).rejects.toThrow('Permission denied');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should throw when response value contains errors field', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { errors: 'Invalid vizId' } }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetTML, HostEvent.GetTML, { vizId: 'bad' },
+            )).rejects.toThrow('Invalid vizId');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should throw when response value contains error field', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { error: 'Not found' } }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetTabs, HostEvent.GetTabs, {},
+            )).rejects.toThrow('Not found');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should stringify object errors instead of producing [object Object]', async () => {
+            const { client } = createHostEventClient();
+            const errorObj = { code: 403, reason: 'Forbidden' };
+            mockProcessTrigger.mockResolvedValue([{ error: errorObj }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetFilters, HostEvent.GetFilters, {},
+            )).rejects.toThrow(JSON.stringify(errorObj));
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should default payload to empty object when null', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { iframeUrl: 'https://ts.example.com' } }]);
+
+            await callMethod(
+                client, UIPassthroughEvent.GetIframeUrl, HostEvent.GetIframeUrl, null,
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.GetIframeUrl, parameters: {} },
+                undefined,
+            );
+        });
+    });
 });

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

@@ -3,18 +3,42 @@ import { processTrigger as processTriggerService } from '../../utils/processTrig
 import { getEmbedConfig } from '../embedConfig';
 import {
     UIPassthroughArrayResponse,
-    UIPassthroughEvent, HostEventRequest, HostEventResponse,
+    UIPassthroughEvent,
+    HostEventRequest,
+    HostEventResponse,
     UIPassthroughRequest,
     UIPassthroughResponse,
     TriggerPayload,
     TriggerResponse,
 } from './contracts';
 
+/** Host events that use getDataWithPassthroughFallback (getter-style APIs) */
+const HOST_EVENT_PASSTHROUGH_MAP: Partial<Record<HostEvent, UIPassthroughEvent>> = {
+    [HostEvent.GetAnswerSession]: UIPassthroughEvent.GetAnswerSession,
+    [HostEvent.GetFilters]: UIPassthroughEvent.GetFilters,
+    [HostEvent.GetIframeUrl]: UIPassthroughEvent.GetIframeUrl,
+    [HostEvent.GetParameters]: UIPassthroughEvent.GetParameters,
+    [HostEvent.GetTML]: UIPassthroughEvent.GetTML,
+    [HostEvent.GetTabs]: UIPassthroughEvent.GetTabs,
+    [HostEvent.getExportRequestForCurrentPinboard]: UIPassthroughEvent.GetExportRequestForCurrentPinboard,
+};
+
 export class HostEventClient {
   iFrame: HTMLIFrameElement;
 
+  /** Host events with custom handlers 
+   * (setters or special logic) - 
+   * bound to instance for protected method access */
+  private readonly customHandlers: Partial<
+    Record<HostEvent, (payload: any, context?: ContextType) => Promise<any>>
+  >;
+
   constructor(iFrame?: HTMLIFrameElement) {
       this.iFrame = iFrame;
+      this.customHandlers = {
+          [HostEvent.Pin]: (p, c) => this.handlePinEvent(p, c),
+          [HostEvent.SaveAnswer]: (p, c) => this.handleSaveAnswerEvent(p, c),
+      };
   }
 
   /**
@@ -44,11 +68,10 @@ export class HostEventClient {
       context?: ContextType,
   ): Promise<UIPassthroughResponse<UIPassthroughEventT>> {
       const response = (await this.triggerUIPassthroughApi(apiName, parameters, context))
-          ?.filter?.((r) => r.error || r.value)[0];
+          ?.find?.((r) => r.error || r.value);
 
       if (!response) {
           const error = `No answer found${parameters.vizId ? ` for vizId: ${parameters.vizId}` : ''}.`;
-           
           throw { error };
       }
 
@@ -57,8 +80,8 @@ export class HostEventClient {
         || (response.value as any)?.error;
 
       if (errors) {
-       
-          throw { error: response.error };
+          const message = typeof errors === 'string' ? errors : JSON.stringify(errors);
+          throw { error: message };
       }
 
       return { ...response.value };
@@ -72,6 +95,36 @@ export class HostEventClient {
       return this.processTrigger(hostEvent, data, context);
   }
 
+  /**
+   * For getter events that return data. Tries UI passthrough first;
+   * if the app doesn't support it (no response data), falls back to
+   * the legacy host event channel. Real errors are thrown as-is.
+   */
+  private async getDataWithPassthroughFallback<UIPassthroughEventT extends UIPassthroughEvent>(
+      passthroughEvent: UIPassthroughEventT,
+      hostEvent: HostEvent,
+      payload: any,
+      context?: ContextType,
+  ): Promise<UIPassthroughResponse<UIPassthroughEventT>> {
+      const response = await this.triggerUIPassthroughApi(
+          passthroughEvent, payload || {}, context,
+      );
+      const matched = response?.find?.((r) => r.error || r.value);
+      if (!matched) {
+          return this.hostEventFallback(hostEvent, payload, context);
+      }
+
+      const errors = matched.error
+          || (matched.value as any)?.errors
+          || (matched.value as any)?.error;
+      if (errors) {
+          const message = typeof errors === 'string' ? errors : JSON.stringify(errors);
+          throw new Error(message);
+      }
+
+      return { ...matched.value };
+  }
+
   /**
    * Setter for the iframe element used for host events
    * @param {HTMLIFrameElement} iFrame - the iframe element to set
@@ -146,16 +199,18 @@ export class HostEventClient {
       payload?: TriggerPayload<PayloadT, HostEventT>,
       context?: ContextT,
   ): Promise<TriggerResponse<PayloadT, HostEventT, ContextType>> {
-      switch (hostEvent) {
-          case HostEvent.Pin:
-              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, context);
+      const customHandler = this.customHandlers[hostEvent];
+      if (customHandler) {
+          return customHandler(payload, context as ContextType) as any;
+      }
+
+      const passthroughEvent = HOST_EVENT_PASSTHROUGH_MAP[hostEvent];
+      if (passthroughEvent) {
+          return this.getDataWithPassthroughFallback(
+              passthroughEvent, hostEvent, payload, context as ContextType,
+          ) as any;
       }
+
+      return this.hostEventFallback(hostEvent, payload, context);
   }
 }

package/src/embed/liveboard.spec.ts

@@ -94,6 +94,37 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should set disabled actions using PersonalizedViewsDropdown alias', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            disabledActions: [Action.PersonalizedViewsDropdown],
+            disabledActionReason: 'Action denied',
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true&${defaultParamsWithoutHiddenActions}&disableAction=[%22${Action.PersonalisedViewsDropdown}%22]&disableHint=Action%20denied&hideAction=[%22${Action.ReportError}%22]${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
+    test('should set hidden actions using OrganizeFavorites alias', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            hiddenActions: [Action.OrganizeFavorites],
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true&${defaultParamsWithoutHiddenActions}&hideAction=[%22${Action.ReportError}%22,%22${Action.OrganiseFavourites}%22]${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
     test('should set disabled actions', async () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             disabledActions: [Action.DownloadAsCsv, Action.DownloadAsPdf, Action.DownloadAsXlsx],
@@ -1011,8 +1042,8 @@ describe('Liveboard/viz embed tests', () => {
                 } as LiveboardViewConfig);
                 liveboardEmbed.render();
                 await executeAfterWait(() => {
-                    // URL: #/embed/viz/{id}/tab/{tabId}?view={viewId} (view at
-                    // END, not middle)
+                    // URL: #/embed/viz/{id}/tab/{tabId}?view={viewId}
+                    // (view at END, not middle)
                     expect(getIFrameSrc()).toMatch(
                         new RegExp(
                             `#/embed/viz/${liveboardId}/tab/${activeTabId}\\?view=${workaroundViewId}`,
@@ -1944,6 +1975,99 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    describe('updateIFrameHeight threshold handling', () => {
+        let mockIFrame: HTMLIFrameElement;
+
+        beforeEach(() => {
+            mockIFrame = document.createElement('iframe');
+            mockIFrame.getBoundingClientRect = jest.fn().mockReturnValue({
+                top: 0,
+                left: 0,
+                bottom: 500,
+                right: 800,
+                width: 800,
+                height: 500,
+            });
+        });
+
+        test('should skip height update when change is below threshold', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+            }) as any;
+
+            liveboardEmbed.iFrame = mockIFrame;
+            document.body.appendChild(mockIFrame);
+            await liveboardEmbed.render();
+
+            const spySetIFrameHeight = jest.spyOn(liveboardEmbed, 'setIFrameHeight');
+
+            // currentHeight is 500; heightToSet = max(510, 500) = 510; change = 10 < 30
+            liveboardEmbed.updateIFrameHeight({ data: 510, type: EmbedEvent.EmbedHeight });
+
+            expect(spySetIFrameHeight).not.toHaveBeenCalled();
+        });
+
+        test('should update height when change meets threshold', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+            }) as any;
+
+            liveboardEmbed.iFrame = mockIFrame;
+            document.body.appendChild(mockIFrame);
+            await liveboardEmbed.render();
+
+            const spySetIFrameHeight = jest.spyOn(liveboardEmbed, 'setIFrameHeight');
+
+            // currentHeight is 500; heightToSet = max(700, 500) = 700; change = 200 >= 30
+            liveboardEmbed.updateIFrameHeight({ data: 700, type: EmbedEvent.EmbedHeight });
+
+            expect(spySetIFrameHeight).toHaveBeenCalledWith(700);
+        });
+
+        test('should use defaultHeight when data is below it and apply threshold', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+                minimumHeight: 800,
+            }) as any;
+
+            liveboardEmbed.iFrame = mockIFrame;
+            document.body.appendChild(mockIFrame);
+            await liveboardEmbed.render();
+
+            const spySetIFrameHeight = jest.spyOn(liveboardEmbed, 'setIFrameHeight');
+
+            // currentHeight is 500; heightToSet = max(100, 800) = 800; change = 300 >= 30
+            liveboardEmbed.updateIFrameHeight({ data: 100, type: EmbedEvent.EmbedHeight });
+
+            expect(spySetIFrameHeight).toHaveBeenCalledWith(800);
+        });
+
+        test('should skip update when height change is exactly at threshold boundary', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                ...defaultViewConfig,
+                fullHeight: true,
+            }) as any;
+
+            liveboardEmbed.iFrame = mockIFrame;
+            document.body.appendChild(mockIFrame);
+            await liveboardEmbed.render();
+
+            const spySetIFrameHeight = jest.spyOn(liveboardEmbed, 'setIFrameHeight');
+
+            // currentHeight is 500; heightToSet = max(529, 500) = 529; change = 29 < 30
+            liveboardEmbed.updateIFrameHeight({ data: 529, type: EmbedEvent.EmbedHeight });
+
+            expect(spySetIFrameHeight).not.toHaveBeenCalled();
+        });
+    });
+
     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(), {

package/src/embed/liveboard.ts

@@ -732,7 +732,8 @@ export class LiveboardEmbed extends V1Embed {
         personalizedViewId?: string,
     ) {
         // Extract view from liveboardId if passed along with it (legacy
-        // approach) View must be appended as query param at the end, not
+        // approach)
+        // View must be appended as query param at the end, not
         // embedded in path
         let liveboardGuid = liveboardId;
         let legacyViewId: string | undefined;
@@ -805,13 +806,21 @@ export class LiveboardEmbed extends V1Embed {
         )}`;
     }
 
+    private HEIGHT_CHANAGE_THRESHOLD = 30;
     /**
      * Set the iframe height as per the computed height received
      * from the ThoughtSpot app.
      * @param data The event payload
      */
     private updateIFrameHeight = (data: MessagePayload) => {
-        this.setIFrameHeight(Math.max(data.data, this.defaultHeight));
+        const currentHeight = this.iFrame.getBoundingClientRect().height;
+        const heightToSet = Math.max(data.data, this.defaultHeight);
+        const heightChange = Math.abs(heightToSet - currentHeight);
+        if (heightChange < this.HEIGHT_CHANAGE_THRESHOLD) {
+            logger.info('Height change is less than the threshold, skipping height update', { heightChange, heightToSet, currentHeight });
+            return;
+        }
+        this.setIFrameHeight(heightToSet);
         this.sendFullHeightLazyLoadData();
     };
 

package/src/embed/sage.ts

@@ -147,7 +147,6 @@ export class SageEmbed extends V1Embed {
      */
     protected viewConfig: SageViewConfig;
 
-     
     constructor(domSelector: DOMSelector, viewConfig: SageViewConfig) {
         viewConfig.embedComponentType = 'SageEmbed';
         super(domSelector, viewConfig);

package/src/embed/search.spec.ts

@@ -527,7 +527,6 @@ describe('Search embed tests', () => {
     test('should set dataPanelCustomGroupsAccordionInitialState to EXPAND_FIRST when passed', async () => {
         const searchEmbed = new SearchBarEmbed(getRootEl() as any, {
             ...defaultViewConfig,
-             
         });
         searchEmbed.render();
         await executeAfterWait(() => {
@@ -541,7 +540,6 @@ describe('Search embed tests', () => {
     test('should set dataPanelCustomGroupsAccordionInitialState to EXPAND_FIRST when passed', async () => {
         const searchEmbed = new SearchEmbed(getRootEl(), {
             ...defaultViewConfig,
-             
             dataPanelCustomGroupsAccordionInitialState:
                 DataPanelCustomColumnGroupsAccordionState.EXPAND_FIRST,
         });

package/src/embed/ts-embed.ts

@@ -34,7 +34,8 @@ import {
     setStyleProperties,
     removeStyleProperties,
     isUndefined,
- getHostEventsConfig } from '../utils';
+    getHostEventsConfig,
+} from '../utils';
 import { getCustomActions } from '../utils/custom-actions';
 import {
     getThoughtSpotHost,
@@ -1392,7 +1393,21 @@ export class TsEmbed {
      * Triggers an event to the embedded app
      * @param {HostEvent} messageType The event type
      * @param {any} data The payload to send with the message
+     * @param {ContextType} context Optional context type to specify the context from which the event is triggered.
+     * Use ContextType.Search for search answer context, ContextType.Answer for answer/explore context,
+     * ContextType.Liveboard for liveboard context, or ContextType.Spotter for spotter context.
+     * Available from SDK version 1.45.2 | ThoughtSpot: 26.3.0.cl
      * @returns A promise that resolves with the response from the embedded app
+     * @example
+     * ```js
+     * // Trigger Pin event with context (SDK: 1.45.2+)
+     * import { HostEvent, ContextType } from '@thoughtspot/visual-embed-sdk';
+     * embed.trigger(HostEvent.Pin, {
+     *   vizId: "123",
+     *   liveboardId: "456"
+     * }, ContextType.Search);
+     * ```
+     * @version SDK: 1.45.2 | ThoughtSpot: 26.3.0.cl (for context parameter)
      */
     public async trigger<HostEventT extends HostEvent, PayloadT, ContextT extends ContextType>(
         messageType: HostEventT,
@@ -1474,8 +1489,33 @@ export class TsEmbed {
     }
 
     /**
-     * Get the current context of the embedded TS component.
-     * @returns The current context object containing the page type and object ids.
+    * Context object for the embedded component.
+    * @returns {ContextObject} The current context object containing the page type and object ids.
+    * @example
+    * ```js
+    * const context = await embed.getCurrentContext();
+    * console.log(context);
+    * 
+    * // Example output
+    * {
+    *   stack: [
+    *     {
+    *       name: 'Liveboard',
+    *       type: ContextType.Liveboard,
+    *       objectIds: {
+    *         liveboardId: '123',
+    *       },
+    *     },
+    *   ],
+    *   currentContext: {
+    *     name: 'Liveboard',
+    *     type: ContextType.Liveboard,
+    *     objectIds: {
+    *       liveboardId: '123',
+    *     },
+    *   },
+    * }
+    * ```
      * @version SDK: 1.45.2 | ThoughtSpot: 26.3.0.cl
      */
     public async getCurrentContext(): Promise<ContextObject> {