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

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

@@ -0,0 +1,225 @@
+import {
+    isValidUpdateFiltersPayload,
+    isValidDrillDownPayload,
+    createValidationError,
+    throwUpdateFiltersValidationError,
+    throwDrillDownValidationError,
+} from './utils';
+import { ERROR_MESSAGE } from '../../errors';
+import { EmbedEvent } from '../../types';
+import { embedEventStatus } from '../../utils';
+
+describe('hostEventClient utils', () => {
+
+    // =========================
+    // UpdateFilters Validation
+    // =========================
+    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 with column', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'region', oper: 'EQ', values: ['North'] },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for valid filter with columnName', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { columnName: 'region', oper: 'EQ', values: ['North'] },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for filter with operator instead of oper', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'region', operator: '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 true for valid filters array with columnName', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: [
+                    { columnName: 'x', oper: 'IN', values: ['a', 'b'] },
+                    { columnName: 'y', oper: 'EQ', values: ['c'] },
+                ],
+            } as any)).toBe(true);
+        });
+
+        it('returns false if one filter in filters array is invalid', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: [
+                    { column: 'x', oper: 'EQ', values: ['a'] },
+                    { column: 'y', values: ['b'] }, // invalid
+                ],
+            } as any)).toBe(false);
+        });
+
+        it('returns false for filter with missing column/columnName', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { oper: 'EQ', values: ['a'] },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for filter with missing operator', () => {
+            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 filter with non-string type', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'x', oper: 'EQ', values: ['a'], type: 123 },
+            } as any)).toBe(false);
+        });
+
+        it('returns true for filter with valid string type', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'x', oper: 'EQ', values: ['a'], type: 'STRING' },
+            } as any)).toBe(true);
+        });
+
+        it('returns false for empty filters array', () => {
+            expect(isValidUpdateFiltersPayload({ filters: [] } as any)).toBe(false);
+        });
+
+        it('returns false if filters is not an array', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: 'invalid',
+            } as any)).toBe(false);
+        });
+
+        it('returns true if filter is valid even when filters is invalid', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'x', oper: 'EQ', values: ['a'] },
+                filters: [{ column: 'y' }], // invalid
+            } as any)).toBe(true);
+        });
+    });
+
+    // =========================
+    // DrillDown Validation
+    // =========================
+    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 object', () => {
+            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);
+        });
+
+        it('returns false if clickedPoint is null', () => {
+            expect(isValidDrillDownPayload({
+                points: { clickedPoint: null },
+            } as any)).toBe(false);
+        });
+
+        it('returns false if selectedPoints is not an array', () => {
+            expect(isValidDrillDownPayload({
+                points: { selectedPoints: 'invalid' },
+            } as any)).toBe(false);
+        });
+
+        it('returns false if both clickedPoint and selectedPoints are invalid', () => {
+            expect(isValidDrillDownPayload({
+                points: { clickedPoint: null, selectedPoints: [] },
+            } as any)).toBe(false);
+        });
+    });
+
+    // =========================
+    // Error Handling
+    // =========================
+    describe('createValidationError', () => {
+        it('throws with message', () => {
+            expect(() => createValidationError('test error')).toThrow('test error');
+        });
+
+        it('throws Error instance with metadata', () => {
+            try {
+                createValidationError('custom msg');
+            } catch (err: any) {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.isValidationError).toBe(true);
+                expect(err.embedErrorDetails).toBeDefined();
+
+                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,74 @@
+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[]; 
+    type?: string; 
+    columnName?: string; 
+    operator?: string 
+  }) => {
+    const hasColumn = typeof f.column === 'string' || typeof f.columnName === 'string';
+    const hasOperator = typeof f.oper === 'string' || typeof f.operator === 'string';
+    const hasValues = Array.isArray(f.values);
+    const validType = !f.type || typeof f.type === 'string';
+  
+    return hasColumn && hasOperator && hasValues && validType;
+  };
+
+  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

@@ -260,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,
@@ -1655,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,
@@ -1975,99 +2013,6 @@ 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

@@ -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;
@@ -767,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);
+        }
     };
 
     /**
@@ -806,21 +832,13 @@ 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) => {
-        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.setIFrameHeight(Math.max(data.data, this.defaultHeight));
         this.sendFullHeightLazyLoadData();
     };
 

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

package/src/embed/spotter-utils.ts

@@ -0,0 +1,65 @@
+import { DefaultAppInitData, ErrorDetailsTypes, EmbedErrorCodes } from '../types';
+import { validateHttpUrl } from '../utils';
+import { ERROR_MESSAGE } from '../errors';
+import type { SpotterSidebarViewConfig } from './conversation';
+
+/**
+ * Resolves enablePastConversationsSidebar with
+ * spotterSidebarConfig taking precedence over the
+ * standalone flag.
+ */
+export const resolveEnablePastConversationsSidebar = (params: {
+    spotterSidebarConfigValue?: boolean;
+    standaloneValue?: boolean;
+}): boolean | undefined => (
+    params.spotterSidebarConfigValue !== undefined
+        ? params.spotterSidebarConfigValue
+        : params.standaloneValue
+);
+
+export function buildSpotterSidebarAppInitData<T extends DefaultAppInitData>(
+    defaultAppInitData: T,
+    viewConfig: {
+        spotterSidebarConfig?: SpotterSidebarViewConfig;
+        enablePastConversationsSidebar?: boolean;
+    },
+    handleError: (err: any) => void,
+): T & { embedParams?: { spotterSidebarConfig?: SpotterSidebarViewConfig } } {
+    const { spotterSidebarConfig, enablePastConversationsSidebar } = viewConfig;
+
+    const resolvedEnablePastConversations = resolveEnablePastConversationsSidebar({
+        spotterSidebarConfigValue: spotterSidebarConfig?.enablePastConversationsSidebar,
+        standaloneValue: enablePastConversationsSidebar,
+    });
+
+    const hasConfig = spotterSidebarConfig || resolvedEnablePastConversations !== undefined;
+    if (!hasConfig) return defaultAppInitData;
+
+    const resolvedSidebarConfig: SpotterSidebarViewConfig = {
+        ...spotterSidebarConfig,
+        ...(resolvedEnablePastConversations !== undefined && {
+            enablePastConversationsSidebar: resolvedEnablePastConversations,
+        }),
+    };
+
+    if (resolvedSidebarConfig.spotterDocumentationUrl !== undefined) {
+        const [isValid, validationError] = validateHttpUrl(resolvedSidebarConfig.spotterDocumentationUrl);
+        if (!isValid) {
+            handleError({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.INVALID_SPOTTER_DOCUMENTATION_URL,
+                code: EmbedErrorCodes.INVALID_URL,
+                error: validationError?.message || ERROR_MESSAGE.INVALID_SPOTTER_DOCUMENTATION_URL,
+            });
+            delete resolvedSidebarConfig.spotterDocumentationUrl;
+        }
+    }
+
+    return {
+        ...defaultAppInitData,
+        embedParams: {
+            ...((defaultAppInitData as any).embedParams || {}),
+            spotterSidebarConfig: resolvedSidebarConfig,
+        },
+    };
+}