@thoughtspot/visual-embed-sdk 1.47.3 → 1.49.0

package/src/embed/auto-frame-renderer.ts

@@ -115,8 +115,9 @@ class AutoFrameRenderer extends TsEmbed {
         delete existingQueryParamsObject[Param.Tsmcp];
 
         const mergedQueryParams = { ...queryParams, ...existingQueryParamsObject };
-        const mergedQueryParamsString = getQueryParamString(mergedQueryParams);
-        const frameSrc = `${this.getEmbedBasePath(mergedQueryParamsString)}${sourceURL.hash.replace('#', '')}`;
+        const mergedQueryParamsString = getQueryParamString(mergedQueryParams, true);
+        const queryString = mergedQueryParamsString ? `?${mergedQueryParamsString}` : '';
+        const frameSrc = `${this.getEmbedBasePath(queryString)}${sourceURL.hash.replace('#', '')}`;
         return frameSrc;
     }
 
@@ -145,8 +146,12 @@ class AutoFrameRenderer extends TsEmbed {
      */
     public async replaceIframe(iframe: HTMLIFrameElement): Promise<void> {
         this.frameToReplace = iframe;
+        if (this.shouldWaitForRenderPromise) {
+            await this.isReadyForRenderPromise;
+        }
         const src = this.getMCPIframeSrc(iframe.src);
         await this.renderIFrame(src);
+        this.isRendered = true;
     }
 }
 

package/src/embed/base.spec.ts

@@ -10,7 +10,7 @@ import * as base from './base';
 import * as embedConfigInstance from './embedConfig';
 import * as resetService from '../utils/resetServices';
 import * as processTrigger from '../utils/processTrigger';
-import { createAndSetInitPromise, getInitPromise, getIsInitCalled, reloadIframe } from './base';
+import { createAndSetInitPromise, getInitPromise, getIsInitCalled, getIsInitCompleted, reloadIframe } from './base';
 
 import {
     executeAfterWait,
@@ -607,4 +607,28 @@ describe('Init Promise Functions', () => {
         const secondPromise = getInitPromise();
         expect(firstPromise).toBe(secondPromise);
     });
+
+    test('getIsInitCompleted returns false (not undefined) before init resolves', () => {
+        // fresh store via beforeEach; init not yet called
+        const result = getIsInitCompleted();
+        expect(result).toBe(false);
+        expect(typeof result).toBe('boolean');
+    });
+
+    test('getIsInitCompleted returns true after init resolves', async () => {
+        base.init({
+            thoughtSpotHost: 'tshost',
+            authType: index.AuthType.None,
+        });
+        await getInitPromise();
+        // flush the finally() microtask
+        await new Promise((r) => setTimeout(r, 0));
+        expect(getIsInitCompleted()).toBe(true);
+    });
+
+    test('getIsInitCompleted returns false when window store is absent', () => {
+        // clear the store from window
+        (window as any)._tsEmbedSDK = {};
+        expect(getIsInitCompleted()).toBe(false);
+    });
 });

package/src/embed/base.ts

@@ -182,9 +182,10 @@ function backwardCompat(embedConfig: EmbedConfig): EmbedConfig {
 }
 
 type InitFlagStore = {
-  initPromise: Promise<ReturnType<typeof init>>;
-  isInitCalled: boolean;
-  initPromiseResolve: (value: ReturnType<typeof init>) => void;
+    initPromise: Promise<ReturnType<typeof init>>;
+    isInitCalled: boolean;
+    isInitCompleted: boolean;
+    initPromiseResolve: (value: ReturnType<typeof init>) => void;
 }
 const initFlagKey = 'initFlagKey';
 
@@ -199,21 +200,34 @@ export const createAndSetInitPromise = (): void => {
     const initFlagStore: InitFlagStore = {
         initPromise,
         isInitCalled: false,
+        isInitCompleted: false,
         initPromiseResolve,
     };
     storeValueInWindow(initFlagKey, initFlagStore, {
         // In case of diff imports the promise might be already set
         ignoreIfAlreadyExists: true,
     });
+    initPromise.finally(() => {
+        const curVal = getValueFromWindow<InitFlagStore>(initFlagKey);
+        if (!curVal) {
+            logger.error('initFlagStore missing when marking init complete');
+            return;
+        }
+        curVal.isInitCompleted = true;
+        storeValueInWindow(initFlagKey, curVal);
+    });
 };
 
 createAndSetInitPromise();
 
 export const getInitPromise = ():
     Promise<
-      ReturnType<typeof init>
+        ReturnType<typeof init>
     > => getValueFromWindow<InitFlagStore>(initFlagKey)?.initPromise;
 
+export const getIsInitCompleted = (): boolean =>
+    !!getValueFromWindow<InitFlagStore>(initFlagKey)?.isInitCompleted;
+
 export const getIsInitCalled = (): boolean => !!getValueFromWindow(initFlagKey)?.isInitCalled;
 
 /**
@@ -319,7 +333,7 @@ export const renderInQueue = (fn: (next?: (val?: any) => void) => Promise<any>):
         return renderQueue;
     }
     // Sending an empty function to keep it consistent with the above usage.
-    return fn(() => {});
+    return fn(() => { });
 };
 
 /**

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

@@ -238,6 +238,99 @@ describe('SpotterAgentEmbed', () => {
         expect(iframeSrc).toContain('hideAction');
     });
 
+    test('should handle disabledActions and disabledActionReason parameters correctly', async () => {
+        fetchMock.mockResponses(
+            JSON.stringify({
+                data: {
+                    ConvAssist__createConversation: {
+                        convId: 'conversationId',
+                        initialCtx: {
+                            type: 'TS_ANSWER',
+                            tsAnsCtx: {
+                                sessionId: 'sessionId',
+                                genNo: 1,
+                                stateKey: {
+                                    transactionId: 'transactionId',
+                                    generationNumber: 1,
+                                },
+                                worksheet: {
+                                    worksheetId: 'worksheetId',
+                                    worksheetName: 'GTM',
+                                },
+                            },
+                        },
+                    },
+                },
+            }),
+            JSON.stringify({
+                data: {
+                    ConvAssist__sendMessage: {
+                        responses: [
+                            {
+                                msgId: 'msgId',
+                                data: {
+                                    asstRespData: {
+                                        tool: 'TS_NLS',
+                                        asstRespText: '',
+                                        nlsAnsData: {
+                                            sageQuerySuggestions: [
+                                                {
+                                                    llmReasoning: {
+                                                        assumptions: '',
+                                                        clarifications: '',
+                                                        interpretation: '',
+                                                        __typename: 'eureka_SageQuerySuggestion_LLMReasoning',
+                                                    },
+                                                    tokens: [],
+                                                    tmlTokens: [],
+                                                    worksheetId: 'worksheetId',
+                                                    description: '',
+                                                    title: '',
+                                                    cached: false,
+                                                    sqlQuery: '',
+                                                    sessionId: 'sessionId',
+                                                    genNo: 2,
+                                                    formulaInfo: [],
+                                                    tmlPhrases: [],
+                                                    stateKey: {
+                                                        transactionId: 'transactionId',
+                                                        generationNumber: 1,
+                                                        __typename: 'sage_auto_complete_v2_ACStateKey',
+                                                    },
+                                                    __typename: 'eureka_SageQuerySuggestion',
+                                                },
+                                            ],
+                                            responseType: 'ANSWER',
+                                            __typename: 'convassist_nls_tool_NLSToolAsstRespData',
+                                        },
+                                        __typename: 'convassist_AsstResponseData',
+                                    },
+                                    __typename: 'convassist_MessageData',
+                                },
+                                type: 'ASST_RESPONSE',
+                                __typename: 'convassist_MessagePayload',
+                            },
+                        ],
+                        __typename: 'convassist_SendMessageResponse',
+                    },
+                },
+            }),
+        );
+
+        const viewConfig: SpotterAgentEmbedViewConfig = {
+            worksheetId: 'worksheetId',
+            disabledActions: [Action.Download, Action.Save],
+            disabledActionReason: 'Upgrade to Pro!',
+        };
+
+        const spotterAgentEmbed = new SpotterAgentEmbed(viewConfig);
+        const result = await spotterAgentEmbed.sendMessage('userMessage');
+
+        const iframeSrc = getIFrameSrc(result.container);
+        expect(iframeSrc).toContain('disableAction');
+        expect(iframeSrc).toContain('disableHint');
+    });
+
     test('should have sendMessageData method', () => {
         const viewConfig: SpotterAgentEmbedViewConfig = {
             worksheetId: 'worksheetId',

package/src/embed/conversation.spec.ts

@@ -10,6 +10,7 @@ import {
     getRootEl,
     defaultParamsWithoutHiddenActions as defaultParams,
     expectUrlMatchesWithParams,
+    expectUrlToHaveParamsWithValues,
     postMessageToParent,
     executeAfterWait,
 } from '../test/test-utils';
@@ -351,6 +352,39 @@ describe('ConversationEmbed', () => {
         );
     });
 
+    it('should render the conversation embed with spotterFileUploadEnabled', async () => {
+        const viewConfig: SpotterEmbedViewConfig = {
+            worksheetId: 'worksheetId',
+            searchOptions: {
+                searchQuery: 'searchQuery',
+            },
+            spotterChatConfig: { spotterFileUploadEnabled: true },
+        };
+
+        const conversationEmbed = new SpotterEmbed(getRootEl(), viewConfig);
+        await conversationEmbed.render();
+        expectUrlMatchesWithParams(
+            getIFrameSrc(),
+            `http://${thoughtSpotHost}/v2/?${defaultParams}&isSpotterExperienceEnabled=true&spotterFileUploadEnabled=true#/embed/insights/conv-assist?worksheet=worksheetId&query=searchQuery`,
+        );
+    });
+
+    it('should render the conversation embed with spotterFileUploadFileTypes', async () => {
+        const viewConfig: SpotterEmbedViewConfig = {
+            worksheetId: 'worksheetId',
+            searchOptions: {
+                searchQuery: 'searchQuery',
+            },
+            spotterChatConfig: { spotterFileUploadFileTypes: { types: ['image/png', 'application/pdf'] } },
+        };
+
+        const conversationEmbed = new SpotterEmbed(getRootEl(), viewConfig);
+        await conversationEmbed.render();
+        expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+            spotterFileUploadFileTypes: JSON.stringify({ types: ['image/png', 'application/pdf'] }),
+        });
+    });
+
     it('should ensure deprecated ConversationEmbed class maintains same functionality as SpotterEmbed', async () => {
         const viewConfig: SpotterEmbedViewConfig = {
             worksheetId: 'worksheetId',

package/src/embed/conversation.ts

@@ -1,6 +1,6 @@
 import isUndefined from 'lodash/isUndefined';
 import { ERROR_MESSAGE } from '../errors';
-import { Param, BaseViewConfig, RuntimeFilter, RuntimeParameter, ErrorDetailsTypes, EmbedErrorCodes, DefaultAppInitData, VisualizationOverrides } from '../types';
+import { Param, BaseViewConfig, RuntimeFilter, RuntimeParameter, ErrorDetailsTypes, EmbedErrorCodes, DefaultAppInitData, VisualizationOverrides, SpotterFileUploadFileTypes } from '../types';
 import { TsEmbed } from './ts-embed';
 import { buildSpotterSidebarAppInitData } from './spotter-utils';
 import { getQueryParamString, getFilterQuery, getRuntimeParameters, setParamIfDefined } from '../utils';
@@ -113,6 +113,21 @@ export interface SpotterChatViewConfig {
      * External MCP tool branding is not affected.
      */
     toolResponseCardBrandingLabel?: string;
+    /**
+     * Enables file upload in the Spotter chat interface.
+     *
+     * Supported embed types: `SpotterEmbed`, `LiveboardEmbed`, `AppEmbed`
+     * @version SDK: 1.49.0 | ThoughtSpot: 26.6.0.cl
+     * @default false
+     */
+    spotterFileUploadEnabled?: boolean;
+    /**
+     * Restricts the allowed file types for Spotter file upload.
+     *
+     * Supported embed types: `SpotterEmbed`, `LiveboardEmbed`, `AppEmbed`
+     * @version SDK: 1.49.0 | ThoughtSpot: 26.6.0.cl
+     */
+    spotterFileUploadFileTypes?: SpotterFileUploadFileTypes;
 }
 
 /**
@@ -450,10 +465,16 @@ export class SpotterEmbed extends TsEmbed {
             const {
                 hideToolResponseCardBranding,
                 toolResponseCardBrandingLabel,
+                spotterFileUploadEnabled,
+                spotterFileUploadFileTypes,
             } = spotterChatConfig;
 
             setParamIfDefined(queryParams, Param.HideToolResponseCardBranding, hideToolResponseCardBranding, true);
             setParamIfDefined(queryParams, Param.ToolResponseCardBrandingLabel, toolResponseCardBrandingLabel);
+            setParamIfDefined(queryParams, Param.SpotterFileUploadEnabled, spotterFileUploadEnabled, true);
+            if (spotterFileUploadFileTypes !== undefined) {
+                queryParams[Param.SpotterFileUploadFileTypes] = JSON.stringify(spotterFileUploadFileTypes);
+            }
         }
 
         return queryParams;

package/src/embed/liveboard.spec.ts

@@ -275,6 +275,20 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should disable isWYSIWYGLiveboardPDFEnabled by default in url', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isWYSIWYGLiveboardPDFEnabled=false${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
     test('should set isLiveboardXLSXCSVDownloadEnabled to true in url', async () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             isLiveboardXLSXCSVDownloadEnabled: true,
@@ -1252,6 +1266,35 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should set spotterFileUploadEnabled parameter in url params', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            spotterChatConfig: { spotterFileUploadEnabled: true },
+        } as LiveboardViewConfig);
+        await liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}${prefixParams}&spotterFileUploadEnabled=true#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
+    test('should set spotterFileUploadFileTypes parameter in url params', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            spotterChatConfig: { spotterFileUploadFileTypes: { types: ['image/png', 'application/pdf'] } },
+        } as LiveboardViewConfig);
+        await liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                spotterFileUploadFileTypes: JSON.stringify({ types: ['image/png', 'application/pdf'] }),
+            });
+        });
+    });
+
     test('should render the liveboard embed with updatedSpotterChatPrompt', async () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             ...defaultViewConfig,
@@ -1315,6 +1358,94 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should include spotterVizConfig in APP_INIT embedParams when spotterViz is provided', async () => {
+        const spotterViz = {
+            brandName: 'MyBrand',
+            brandHeadline: "Hi, there! I'm",
+            description: 'Ask questions about your data',
+            inputChatPlaceholder: 'Ask a question...',
+            hideStarterPrompts: false,
+            customStarterPrompts: [
+                { id: '1', displayText: 'Show revenue by region', fullPrompt: 'Show revenue by region' },
+                { id: '2', displayText: 'Top customers', fullPrompt: 'Top customers by sales' },
+            ],
+        };
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            spotterViz,
+        } as LiveboardViewConfig);
+
+        mockMessageChannel();
+        await liveboardEmbed.render();
+
+        const mockPort: any = { postMessage: jest.fn() };
+        await executeAfterWait(() => {
+            postMessageToParent(getIFrameEl().contentWindow, { type: EmbedEvent.APP_INIT, data: {} }, mockPort);
+        });
+        await executeAfterWait(() => {
+            expect(mockPort.postMessage).toHaveBeenCalledWith({
+                type: EmbedEvent.APP_INIT,
+                data: expect.objectContaining({
+                    embedParams: expect.objectContaining({
+                        spotterVizConfig: spotterViz,
+                    }),
+                }),
+            });
+        });
+    });
+
+    test('should pass brandHeadline through spotterVizConfig in APP_INIT', async () => {
+        const spotterViz = { brandName: 'MyBrand', brandHeadline: "Hi, there! I'm" };
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+            spotterViz,
+        } as LiveboardViewConfig);
+
+        mockMessageChannel();
+        await liveboardEmbed.render();
+
+        const mockPort: any = { postMessage: jest.fn() };
+        await executeAfterWait(() => {
+            postMessageToParent(getIFrameEl().contentWindow, { type: EmbedEvent.APP_INIT, data: {} }, mockPort);
+        });
+        await executeAfterWait(() => {
+            expect(mockPort.postMessage).toHaveBeenCalledWith({
+                type: EmbedEvent.APP_INIT,
+                data: expect.objectContaining({
+                    embedParams: expect.objectContaining({
+                        spotterVizConfig: expect.objectContaining({
+                            brandHeadline: "Hi, there! I'm",
+                        }),
+                    }),
+                }),
+            });
+        });
+    });
+
+    test('should not include spotterVizConfig in APP_INIT when spotterViz is not provided', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+
+        mockMessageChannel();
+        await liveboardEmbed.render();
+
+        const mockPort: any = { postMessage: jest.fn() };
+        await executeAfterWait(() => {
+            postMessageToParent(getIFrameEl().contentWindow, { type: EmbedEvent.APP_INIT, data: {} }, mockPort);
+        });
+        await executeAfterWait(() => {
+            const callArgs = mockPort.postMessage.mock.calls[0][0];
+            expect(callArgs.type).toBe(EmbedEvent.APP_INIT);
+            if (callArgs.data.embedParams) {
+                expect(callArgs.data.embedParams.spotterVizConfig).toBeUndefined();
+            }
+        });
+    });
+
     test('SetActiveTab Hostevent should not trigger the navigate event with the correct path, for vizEmbed', async () => {
         const mockProcessTrigger = jest.spyOn(tsEmbed.TsEmbed.prototype, 'trigger');
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -1821,6 +1952,37 @@ describe('Liveboard/viz embed tests', () => {
             addEventListenerSpy.mockRestore();
         });
 
+        test('should listen to scroll and resize changes from scrollable iframe ancestors', async () => {
+            const scrollContainer = getRootEl();
+            scrollContainer.style.overflow = 'auto';
+
+            const scrollContainerAddEventListenerSpy = jest.spyOn(scrollContainer, 'addEventListener');
+            const resizeObserveSpy = jest.fn();
+            const resizeDisconnectSpy = jest.fn();
+            (window as any).ResizeObserver = jest.fn().mockImplementation(() => ({
+                observe: resizeObserveSpy,
+                disconnect: resizeDisconnectSpy,
+            }));
+
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                liveboardId,
+                fullHeight: true,
+                lazyLoadingForFullHeight: true,
+                enableScrollableContainerLazyLoading: true,
+            } as LiveboardViewConfig);
+
+            await liveboardEmbed.render();
+
+            await executeAfterWait(() => {
+                expect(scrollContainerAddEventListenerSpy).toHaveBeenCalledWith('scroll', expect.any(Function));
+                expect(resizeObserveSpy).toHaveBeenCalledWith(scrollContainer);
+            }, 100);
+
+            liveboardEmbed.destroy();
+            expect(resizeDisconnectSpy).toHaveBeenCalled();
+        });
+
         test('should remove window event listeners on destroy when fullHeight and lazyLoadingForFullHeight are enabled', async () => {
             const removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
 
@@ -1836,7 +1998,7 @@ describe('Liveboard/viz embed tests', () => {
             liveboardEmbed.destroy();
 
             expect(removeEventListenerSpy).toHaveBeenCalledWith('resize', expect.anything());
-            expect(removeEventListenerSpy).toHaveBeenCalledWith('scroll', expect.anything());
+            expect(removeEventListenerSpy).toHaveBeenCalledWith('scroll', expect.anything(), true);
 
             removeEventListenerSpy.mockRestore();
         });