@thoughtspot/visual-embed-sdk 1.46.4 → 1.46.5

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

@@ -1,20 +1,65 @@
 import { ContextType, HostEvent } from '../../types';
 import { processTrigger as processTriggerService } from '../../utils/processTrigger';
 import { getEmbedConfig } from '../embedConfig';
+import {
+    isValidUpdateFiltersPayload,
+    isValidDrillDownPayload,
+    throwUpdateFiltersValidationError,
+    throwDrillDownValidationError,
+} from './utils';
 import {
     UIPassthroughArrayResponse,
-    UIPassthroughEvent, HostEventRequest, HostEventResponse,
+    UIPassthroughEvent,
+    HostEventRequest,
+    HostEventResponse,
     UIPassthroughRequest,
     UIPassthroughResponse,
     TriggerPayload,
     TriggerResponse,
 } from './contracts';
 
+/**
+ * Maps HostEvent to its corresponding UIPassthroughEvent.
+ * Includes both custom-handler events (Pin, SaveAnswer, UpdateFilters, DrillDown)
+ * and getter events (GetAnswerSession, GetFilters, etc.) that use getDataWithPassthroughFallback.
+ */
+const PASSTHROUGH_MAP: Partial<Record<HostEvent, UIPassthroughEvent>> = {
+    // Custom handlers (setters with special logic)
+    [HostEvent.Pin]: UIPassthroughEvent.PinAnswerToLiveboard,
+    [HostEvent.SaveAnswer]: UIPassthroughEvent.SaveAnswer,
+    [HostEvent.UpdateFilters]: UIPassthroughEvent.UpdateFilters,
+    [HostEvent.DrillDown]: UIPassthroughEvent.Drilldown,
+    // Getters (use getDataWithPassthroughFallback)
+    [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;
 
+  /** Cached list of available UI passthrough keys from the embedded app */
+  private availablePassthroughKeysCache: string[] | null = null;
+
+  /** 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),
+          [HostEvent.UpdateFilters]: (p, c) => this.handleUpdateFiltersEvent(p, c),
+          [HostEvent.DrillDown]: (p, c) => this.handleDrillDownEvent(p, c),
+      };
   }
 
   /**
@@ -44,11 +89,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 +101,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 +116,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
@@ -80,6 +154,27 @@ export class HostEventClient {
       this.iFrame = iFrame;
   }
 
+  /**
+   * Fetches the list of available UI passthrough keys from the embedded app.
+   * Result is cached for the session. Returns empty array on failure.
+   */
+  private async getAvailableUIPassthroughKeys(context?: ContextType): Promise<string[]> {
+      if (this.availablePassthroughKeysCache !== null) {
+          return this.availablePassthroughKeysCache;
+      }
+      try {
+          const response = await this.triggerUIPassthroughApi(
+              UIPassthroughEvent.GetAvailableUIPassthroughs, {}, context,
+          );
+          const matched = response?.find?.((r) => r.value && !r.error);
+          const keys = matched?.value?.keys;
+          this.availablePassthroughKeysCache = Array.isArray(keys) ? keys : [];
+          return this.availablePassthroughKeysCache;
+      } catch {
+          return [];
+      }
+  }
+
   public async triggerUIPassthroughApi<UIPassthroughEventT extends UIPassthroughEvent>(
       apiName: UIPassthroughEventT,
       parameters: UIPassthroughRequest<UIPassthroughEventT>,
@@ -137,6 +232,37 @@ export class HostEventClient {
       };
   }
 
+  protected handleUpdateFiltersEvent(
+    payload: HostEventRequest<HostEvent.UpdateFilters>,
+    context?: ContextType,
+  ): Promise<any> {
+    if (!isValidUpdateFiltersPayload(payload)) {
+      throwUpdateFiltersValidationError();
+    }
+
+    return this.handleHostEventWithParam(UIPassthroughEvent.UpdateFilters, payload, context as ContextType);
+  }
+
+  protected handleDrillDownEvent(
+    payload: HostEventRequest<HostEvent.DrillDown>,
+    context?: ContextType,
+  ): Promise<any> {
+    if (!isValidDrillDownPayload(payload)) {
+      throwDrillDownValidationError();
+    }
+
+    return this.handleHostEventWithParam(UIPassthroughEvent.Drilldown, payload, context as ContextType);
+  }
+
+  /**
+   * Dispatches a host event using the appropriate channel:
+   * 1. If the embedded app supports UI passthrough for this event, use it (custom handler or getter).
+   * 2. Otherwise fall back to the legacy host event channel.
+   *
+   * @param hostEvent - The host event to trigger
+   * @param payload - Optional payload for the event
+   * @param context - Optional context (e.g. vizId) for scoped operations
+   */
   public async triggerHostEvent<
     HostEventT extends HostEvent,
     PayloadT,
@@ -146,16 +272,21 @@ 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];
+      const passthroughEvent = PASSTHROUGH_MAP[hostEvent];
+
+      // If embedded app supports passthrough but not this event, use legacy channel
+      const keys = passthroughEvent ? await this.getAvailableUIPassthroughKeys(context as ContextType) : [];
+      if (passthroughEvent && keys.length > 0 && !keys.includes(passthroughEvent)) {
+          return this.hostEventFallback(hostEvent, payload, context) as any;
       }
+
+      // Custom handler (setters) > getter passthrough > legacy fallback
+      return (customHandler
+          ? customHandler(payload, context as ContextType)
+          : passthroughEvent
+              ? this.getDataWithPassthroughFallback(passthroughEvent, hostEvent, payload, context as ContextType)
+              : this.hostEventFallback(hostEvent, payload, context)
+      ) as any;
   }
 }

package/src/embed/hostEventClient/utils.spec.ts

@@ -0,0 +1,137 @@
+import {
+    isValidUpdateFiltersPayload,
+    isValidDrillDownPayload,
+    createValidationError,
+    throwUpdateFiltersValidationError,
+    throwDrillDownValidationError,
+} from './utils';
+import { ERROR_MESSAGE } from '../../errors';
+import { EmbedEvent } from '../../types';
+import { embedEventStatus } from '../../utils';
+
+describe('hostEventClient utils', () => {
+    describe('isValidUpdateFiltersPayload', () => {
+        it('returns false for undefined', () => {
+            expect(isValidUpdateFiltersPayload(undefined)).toBe(false);
+        });
+
+        it('returns false for empty payload', () => {
+            expect(isValidUpdateFiltersPayload({})).toBe(false);
+        });
+
+        it('returns true for valid filter', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'region', oper: 'EQ', values: ['North'] },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for valid filters array', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: [
+                    { column: 'x', oper: 'IN', values: ['a', 'b'] },
+                    { column: 'y', oper: 'EQ', values: ['c'] },
+                ],
+            } as any)).toBe(true);
+        });
+
+        it('returns false for filter with missing column', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { oper: 'EQ', values: ['a'] },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for filter with missing oper', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'x', values: ['a'] },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for filter with non-array values', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'x', oper: 'EQ', values: 'a' },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for empty filters array', () => {
+            expect(isValidUpdateFiltersPayload({ filters: [] } as any)).toBe(false);
+        });
+    });
+
+    describe('isValidDrillDownPayload', () => {
+        it('returns false for undefined', () => {
+            expect(isValidDrillDownPayload(undefined)).toBe(false);
+        });
+
+        it('returns false for empty payload', () => {
+            expect(isValidDrillDownPayload({})).toBe(false);
+        });
+
+        it('returns false for empty points', () => {
+            expect(isValidDrillDownPayload({ points: {} } as any)).toBe(false);
+        });
+
+        it('returns false for non-object points', () => {
+            expect(isValidDrillDownPayload({ points: 'invalid' } as any)).toBe(false);
+        });
+
+        it('returns true for clickedPoint', () => {
+            expect(isValidDrillDownPayload({
+                points: { clickedPoint: 'point-1' },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for selectedPoints', () => {
+            expect(isValidDrillDownPayload({
+                points: { selectedPoints: ['p1', 'p2'] },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for both clickedPoint and selectedPoints', () => {
+            expect(isValidDrillDownPayload({
+                points: { clickedPoint: 'p1', selectedPoints: ['p2'] },
+            } as any)).toBe(true);
+        });
+
+        it('returns false for selectedPoints empty array', () => {
+            expect(isValidDrillDownPayload({
+                points: { selectedPoints: [] },
+            } as any)).toBe(false);
+        });
+    });
+
+    describe('createValidationError', () => {
+        it('throws with message and embedErrorDetails', () => {
+            expect(() => createValidationError('test error')).toThrow('test error');
+
+            try {
+                createValidationError('custom msg');
+            } catch (err: any) {
+                expect(err.isValidationError).toBe(true);
+                expect(err.embedErrorDetails).toMatchObject({
+                    type: EmbedEvent.Error,
+                    data: {
+                        errorType: 'VALIDATION_ERROR',
+                        message: 'custom msg',
+                        code: 'HOST_EVENT_VALIDATION',
+                        error: 'custom msg',
+                    },
+                    status: embedEventStatus.END,
+                });
+            }
+        });
+    });
+
+    describe('throwUpdateFiltersValidationError', () => {
+        it('throws with UPDATEFILTERS_INVALID_PAYLOAD message', () => {
+            expect(() => throwUpdateFiltersValidationError())
+                .toThrow(ERROR_MESSAGE.UPDATEFILTERS_INVALID_PAYLOAD);
+        });
+    });
+
+    describe('throwDrillDownValidationError', () => {
+        it('throws with DRILLDOWN_INVALID_PAYLOAD message', () => {
+            expect(() => throwDrillDownValidationError())
+                .toThrow(ERROR_MESSAGE.DRILLDOWN_INVALID_PAYLOAD);
+        });
+    });
+});

package/src/embed/hostEventClient/utils.ts

@@ -0,0 +1,61 @@
+import { EmbedErrorCodes, EmbedEvent, ErrorDetailsTypes, HostEvent } from '../../types';
+import { ERROR_MESSAGE } from '../../errors';
+import { HostEventRequest } from './contracts';
+import { embedEventStatus } from '../../utils';
+
+export function isValidUpdateFiltersPayload(
+  payload: HostEventRequest<HostEvent.UpdateFilters> | undefined,
+): boolean {
+  if (!payload) return false;
+
+  const isValidFilter = (f: { column?: string; oper?: string; values?: unknown[] }) =>
+    !!f && typeof f.column === 'string' && typeof f.oper === 'string' && Array.isArray(f.values);
+
+  const hasValidFilter = payload.filter && isValidFilter(payload.filter);
+  const hasValidFilters = Array.isArray(payload.filters) && payload.filters.length > 0 && payload.filters.every(isValidFilter);
+
+  return !!(hasValidFilter || hasValidFilters);
+}
+
+export function isValidDrillDownPayload(
+  payload: HostEventRequest<HostEvent.DrillDown> | undefined,
+): boolean {
+  if (!payload) return false;
+
+  const points = payload.points;
+  if (!points || typeof points !== 'object') return false;
+
+  const hasClickedPoint = 'clickedPoint' in points && points.clickedPoint != null;
+  const hasSelectedPoints = Array.isArray(points.selectedPoints) && points.selectedPoints.length > 0;
+
+  return hasClickedPoint || hasSelectedPoints;
+}
+
+export type ValidationError = Error & {
+  isValidationError?: boolean;
+  embedErrorDetails?: { type: EmbedEvent.Error; data: { errorType: ErrorDetailsTypes; message: string; code: EmbedErrorCodes; error: string }; status: typeof embedEventStatus.END };
+};
+
+export function createValidationError(message: string): never {
+  const err = new Error(message) as ValidationError;
+  err.isValidationError = true;
+  err.embedErrorDetails = {
+    type: EmbedEvent.Error,
+    data:{
+    errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+    message,
+    code: EmbedErrorCodes.HOST_EVENT_VALIDATION,
+    error: message
+    },
+    status:embedEventStatus.END
+  };
+  throw err;
+}
+
+export function throwUpdateFiltersValidationError(): never {
+  createValidationError(ERROR_MESSAGE.UPDATEFILTERS_INVALID_PAYLOAD);
+}
+
+export function throwDrillDownValidationError(): never {
+  createValidationError(ERROR_MESSAGE.DRILLDOWN_INVALID_PAYLOAD);
+}

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],
@@ -229,6 +260,21 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should set isWYSIWYGLiveboardPDFEnabled to true in url', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            isContinuousLiveboardPDFEnabled: true,
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isWYSIWYGLiveboardPDFEnabled=true${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
     test('should set isLiveboardXLSXCSVDownloadEnabled to true in url', async () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             isLiveboardXLSXCSVDownloadEnabled: true,
@@ -1011,8 +1057,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}`,
@@ -1624,6 +1670,29 @@ describe('Liveboard/viz embed tests', () => {
             });
         });
 
+        test('should send correct visible data when RequestVisibleEmbedCoordinates is triggered', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                liveboardId,
+                fullHeight: true,
+                lazyLoadingMargin: '10px',
+            } as LiveboardViewConfig);
+
+            const mockTrigger = jest.spyOn(liveboardEmbed, 'trigger');
+
+            await liveboardEmbed.render();
+
+            // Trigger the lazy load data calculation
+            (liveboardEmbed as any).sendFullHeightLazyLoadData();
+
+            expect(mockTrigger).not.toHaveBeenCalledWith(HostEvent.VisibleEmbedCoordinates, {
+                top: 0,
+                height: 500,
+                left: 0,
+                width: 650,
+            });
+        });
+
         test('should calculate correct visible data for partially visible full height element', async () => {
             mockIFrame.getBoundingClientRect = jest.fn().mockReturnValue({
                 top: -50,

package/src/embed/liveboard.ts

@@ -387,6 +387,24 @@ export interface LiveboardViewConfig extends BaseViewConfig, LiveboardOtherViewC
      * ```
      */
     isPNGInScheduledEmailsEnabled?: boolean;
+    /**
+     * Enables the 'what you see is what you get' PDF export for Liveboards. Each tab is rendered on a single page 
+     * following the exact UI layout, instead of splitting visualizations across multiple A4 pages. 
+     * This feature is GA from version 26.5.0.cl and is enabled by default on embed deployments.
+     *
+     * Supported embed types: `AppEmbed`, `LiveboardEmbed`
+     * @type {boolean}
+     * @version SDK: 1.48.0 | ThoughtSpot: 26.5.0.cl
+     * @example
+     * ```js
+     * // Replace <EmbedComponent> with embed component name. For example, AppEmbed or LiveboardEmbed
+     * const embed = new <EmbedComponent>('#tsEmbed', {
+     *    ... // other embed view config
+     *    isContinuousLiveboardPDFEnabled: true,
+     * })
+     * ```
+     */
+    isContinuousLiveboardPDFEnabled?: boolean;
     /**
      * This flag is used to enable/disable the XLSX/CSV download option for Liveboards
      *
@@ -598,6 +616,7 @@ export class LiveboardEmbed extends V1Embed {
             updatedSpotterChatPrompt,
             spotterChatConfig,
             isThisPeriodInDateFiltersEnabled,
+            isContinuousLiveboardPDFEnabled,
         } = this.viewConfig;
 
         const preventLiveboardFilterRemoval = this.viewConfig.preventLiveboardFilterRemoval
@@ -708,6 +727,10 @@ export class LiveboardEmbed extends V1Embed {
             params[Param.IsThisPeriodInDateFiltersEnabled] = isThisPeriodInDateFiltersEnabled;
         }
 
+        if (isContinuousLiveboardPDFEnabled !== undefined) {
+            params[Param.IsWYSIWYGLiveboardPDFEnabled] = isContinuousLiveboardPDFEnabled;
+        }
+
         params[Param.LiveboardHeaderSticky] = isLiveboardHeaderSticky;
         params[Param.LiveboardHeaderV2] = isLiveboardCompactHeaderEnabled;
         params[Param.ShowLiveboardVerifiedBadge] = showLiveboardVerifiedBadge;
@@ -732,7 +755,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;
@@ -766,7 +790,10 @@ export class LiveboardEmbed extends V1Embed {
 
     private sendFullHeightLazyLoadData = () => {
         const data = calculateVisibleElementData(this.iFrame);
-        this.trigger(HostEvent.VisibleEmbedCoordinates, data);
+        // this should be fired only if the lazyLoadingForFullHeight and fullHeight are true
+        if(this.viewConfig.lazyLoadingForFullHeight && this.viewConfig.fullHeight){
+            this.trigger(HostEvent.VisibleEmbedCoordinates, data);
+        }
     };
 
     /**

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/spotter-utils.spec.ts

@@ -0,0 +1,56 @@
+import { resolveEnablePastConversationsSidebar, buildSpotterSidebarAppInitData } from './spotter-utils';
+import { ErrorDetailsTypes, EmbedErrorCodes } from '../types';
+import { ERROR_MESSAGE } from '../errors';
+
+describe('resolveEnablePastConversationsSidebar', () => {
+    it('prefers spotterSidebarConfig value over standalone', () => {
+        expect(resolveEnablePastConversationsSidebar({ spotterSidebarConfigValue: true, standaloneValue: false })).toBe(true);
+        expect(resolveEnablePastConversationsSidebar({ spotterSidebarConfigValue: false, standaloneValue: true })).toBe(false);
+    });
+
+    it('falls back to standalone when spotterSidebarConfig value is absent', () => {
+        expect(resolveEnablePastConversationsSidebar({ standaloneValue: true })).toBe(true);
+    });
+
+    it('returns undefined when both are absent', () => {
+        expect(resolveEnablePastConversationsSidebar({})).toBeUndefined();
+    });
+});
+
+describe('buildSpotterSidebarAppInitData', () => {
+    const base = { type: 'APP_INIT' } as any;
+    const noopError = jest.fn();
+
+    it('returns base unchanged when no sidebar config or standalone flag', () => {
+        const result = buildSpotterSidebarAppInitData(base, {}, noopError);
+        expect(result).toBe(base);
+    });
+
+    it('nests spotterSidebarConfig under embedParams', () => {
+        const result = buildSpotterSidebarAppInitData(base, {
+            spotterSidebarConfig: { enablePastConversationsSidebar: true, spotterSidebarTitle: 'Chats' },
+        }, noopError);
+        expect(result.embedParams?.spotterSidebarConfig).toEqual({
+            enablePastConversationsSidebar: true,
+            spotterSidebarTitle: 'Chats',
+        });
+    });
+
+    it('promotes standalone flag into spotterSidebarConfig.enablePastConversationsSidebar', () => {
+        const result = buildSpotterSidebarAppInitData(base, { enablePastConversationsSidebar: true }, noopError);
+        expect(result.embedParams?.spotterSidebarConfig?.enablePastConversationsSidebar).toBe(true);
+    });
+
+    it('calls handleError and strips spotterDocumentationUrl when invalid', () => {
+        const handleError = jest.fn();
+        const result = buildSpotterSidebarAppInitData(base, {
+            spotterSidebarConfig: { spotterDocumentationUrl: 'not-a-url' },
+        }, handleError);
+        expect(handleError).toHaveBeenCalledWith(expect.objectContaining({
+            errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+            message: ERROR_MESSAGE.INVALID_SPOTTER_DOCUMENTATION_URL,
+            code: EmbedErrorCodes.INVALID_URL,
+        }));
+        expect(result.embedParams?.spotterSidebarConfig?.spotterDocumentationUrl).toBeUndefined();
+    });
+});