@thoughtspot/visual-embed-sdk 1.49.2 → 1.50.0

package/src/embed/liveboard.ts

@@ -574,6 +574,12 @@ export interface LiveboardViewConfig extends BaseViewConfig, LiveboardOtherViewC
      *        inputChatPlaceholder: 'Ask a question...',
      *        hideStarterPrompts: false,
      *        customStarterPrompts: [{ id: '1', displayText: 'Top products', fullPrompt: 'What are the top products by revenue?' }],
+     *        // loaderHeadline and loaderTips require SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     *        loaderHeadline: 'Crunching the numbers...',
+     *        loaderTips: [
+     *            { label: 'Tip', text: 'try asking about revenue by region' },
+     *            { label: 'Tip', text: 'use natural language' },
+     *        ],
      *    },
      * })
      * ```

package/src/embed/spotter-viz-utils.ts

@@ -32,6 +32,12 @@ export interface SpotterVizStarterPrompt {
  *        customStarterPrompts: [
  *            { id: '1', displayText: 'Top products', fullPrompt: 'What are the top products by revenue?' }
  *        ],
+ *        // loaderHeadline and loaderTips require SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+ *        loaderHeadline: 'Crunching the numbers...',
+ *        loaderTips: [
+ *            { label: 'Tip', text: 'try asking about revenue by region' },
+ *            { label: 'Tip', text: 'use natural language' },
+ *        ],
  *    },
  * })
  * ```
@@ -76,6 +82,30 @@ export interface SpotterVizConfig {
      * @version SDK: 1.50.0 | ThoughtSpot Cloud: 26.7.0.cl
      */
     inputChatPlaceholder?: string;
+    /**
+     * Custom headline text shown in the SpotterViz loading state.
+     * Replaces the default loading headline.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     */
+    loaderHeadline?: string;
+    /**
+     * Custom tips shown in the SpotterViz loading state.
+     * Replaces the default loading tips with the provided list.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     */
+    loaderTips?: SpotterVizLoaderTip[];
+}
+
+/**
+ * A single tip shown in the SpotterViz loading state.
+ * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+ * @group Embed components
+ */
+export interface SpotterVizLoaderTip {
+    /** Short label rendered alongside the tip (e.g. "Tip"). */
+    label: string;
+    /** Tip body text. */
+    text: string;
 }
 
 export function buildSpotterVizAppInitData<T extends DefaultAppInitData>(

package/src/index.ts

@@ -33,7 +33,7 @@ import { SearchEmbed, SearchViewConfig } from './embed/search';
 import { SearchBarEmbed, SearchBarViewConfig } from './embed/search-bar';
 import { SpotterAgentEmbed, SpotterAgentEmbedViewConfig, BodylessConversation, BodylessConversationViewConfig} from './embed/bodyless-conversation';
 import { SpotterEmbed, SpotterEmbedViewConfig, SpotterChatViewConfig, SpotterSidebarViewConfig, ConversationEmbed, ConversationViewConfig } from './embed/conversation';
-import { SpotterVizConfig, SpotterVizStarterPrompt } from './embed/spotter-viz-utils';
+import { SpotterVizConfig, SpotterVizStarterPrompt, SpotterVizLoaderTip } from './embed/spotter-viz-utils';
 import {
     AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter,
 } from './auth';
@@ -143,6 +143,7 @@ export {
     LiveboardViewConfig,
     SpotterVizConfig,
     SpotterVizStarterPrompt,
+    SpotterVizLoaderTip,
     AppViewConfig,
     PrefetchFeatures,
     FrameParams,

package/src/mixpanel-service.spec.ts

@@ -89,4 +89,19 @@ describe('Unit test for mixpanel', () => {
         expect(logger.error).toHaveBeenCalled();
         expect(mixpanel.register_once).not.toHaveBeenCalled();
     });
+
+    test('logs error when mixpanel.init throws (covers catch block)', () => {
+        testResetMixpanel();
+        jest.spyOn(logger, 'error').mockImplementation(() => {});
+        (mixpanel.init as jest.Mock).mockImplementationOnce(() => {
+            throw new Error('mixpanel init failed');
+        });
+        const sessionInfo = {
+            mixpanelToken: 'abc123',
+            userGUID: '12345',
+            isPublicUser: false,
+        } as SessionInfo;
+        initMixpanel(sessionInfo);
+        expect(logger.error).toHaveBeenCalledWith('Error initializing mixpanel', expect.any(Error));
+    });
 });

package/src/types.ts

@@ -963,7 +963,8 @@ export interface BaseViewConfig extends ApiInterceptFlags {
      * The list of actions to completely remove from the embedded view.
      * Hidden actions are not visible to the user at all (fully removed from the UI).
      * Use this when you want to remove an action entirely.
-     * To keep an action visible but non-interactive (grayed out), use {@link disabledActions} instead.
+     * To keep an action visible but non-interactive (grayed out), use {@link
+     * disabledActions} instead.
      *
      * Supported embed types: `AppEmbed`, `LiveboardEmbed`, `SearchEmbed`, `SpotterAgentEmbed`, `SpotterEmbed`, `SearchBarEmbed`
      * @version SDK: 1.6.0 | ThoughtSpot: ts8.nov.cl, 8.4.1.sw
@@ -983,7 +984,8 @@ export interface BaseViewConfig extends ApiInterceptFlags {
      * (...), and the contextual menu. These will be only actions that
      * are visible to the user.
      * Use this as an allowlist — only the actions listed here will be shown.
-     * All other actions will be hidden. Use either this or {@link hiddenActions}, not both.
+     * All other actions will be hidden. Use either this or {@link hiddenActions}, not
+     * both.
      *
      * Supported embed types: `AppEmbed`, `LiveboardEmbed`, `SearchEmbed`, `SpotterAgentEmbed`, `SpotterEmbed`, `SearchBarEmbed`
      * @version SDK: 1.6.0 | ThoughtSpot: ts8.nov.cl, 8.4.1.sw
@@ -3760,10 +3762,11 @@ export enum EmbedEvent {
     EmbedPageContextChanged = 'EmbedPageContextChanged',
 
     /**
-     * Represents a special embed event that is triggered whenever any host event is subscribed.
+     * Represents a special embed event that is triggered whenever any host event is
+     * subscribed.
      *
-     * You can listen to this event when you need to dispatch a host event during load or render,
-     * particularly in situations where timing issues may occur.
+     * You can listen to this event when you need to dispatch a host event during load or
+     * render, particularly in situations where timing issues may occur.
      *
      * @example
      * ```js
@@ -6016,6 +6019,27 @@ export enum HostEvent {
      * ```
      */
     InitSpotterVizConversation = 'InitSpotterVizConversation',
+
+    /**
+     * Opens the SpotterViz panel.
+     * @version SDK: 1.50.0 | ThoughtSpot Cloud: 26.7.0.cl
+     * @example
+     * ```js
+     * liveboardEmbed.trigger(HostEvent.OpenSpotterVizPanel);
+     * ```
+     */
+    OpenSpotterVizPanel = 'OpenSpotterVizPanel',
+
+    /**
+     * Closes the SpotterViz panel.
+     * @version SDK: 1.50.0 | ThoughtSpot Cloud: 26.7.0.cl
+     * @example
+     * ```js
+     * liveboardEmbed.trigger(HostEvent.CloseSpotterVizPanel);
+     * ```
+     */
+    CloseSpotterVizPanel = 'CloseSpotterVizPanel',
+
     /**
      * Clears browser cache and fetches new data for liveboard ChartViz Containers.
      * Requires `enableLiveboardDataCache` to be enabled.
@@ -7972,7 +7996,73 @@ export enum Action {
      * ```
      * @version SDK: 1.49.0 | ThoughtSpot Cloud: 26.6.0.cl
      */
-    RefreshLiveboardBrowserCache = 'refreshLiveboardBrowserCache',    
+    RefreshLiveboardBrowserCache = 'refreshLiveboardBrowserCache',
+    /**
+     * Controls visibility and disable state of the share action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystShare]
+     * disabledActions: [Action.SpotterAnalystShare]
+     * ```
+     */
+    SpotterAnalystShare = 'spotterAnalystShare',
+    /**
+     * Controls visibility and disable state of the edit action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystEdit]
+     * disabledActions: [Action.SpotterAnalystEdit]
+     * ```
+     */
+    SpotterAnalystEdit = 'spotterAnalystEdit',
+    /**
+     * Controls visibility and disable state of the create action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystCreate]
+     * disabledActions: [Action.SpotterAnalystCreate]
+     * ```
+     */
+    SpotterAnalystCreate = 'spotterAnalystCreate',
+    /**
+     * Controls visibility and disable state of the delete action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystDelete]
+     * disabledActions: [Action.SpotterAnalystDelete]
+     * ```
+     */
+    SpotterAnalystDelete = 'spotterAnalystDelete',
+    /**
+     * Controls visibility and disable state of the make a copy action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystMakeACopy]
+     * disabledActions: [Action.SpotterAnalystMakeACopy]
+     * ```
+     */
+    SpotterAnalystMakeACopy = 'spotterAnalystMakeACopy',
+    /**
+     * Controls visibility and disable state of the sidebar
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystSidebar]
+     * disabledActions: [Action.SpotterAnalystSidebar]
+     * ```
+     */
+    SpotterAnalystSidebar = 'spotterAnalystSidebar',
 }
 export interface AnswerServiceType {
     getAnswer?: (offset: number, batchSize: number) => any;

package/src/utils/custom-actions.spec.ts

@@ -429,6 +429,34 @@ describe('getCustomActions function', () => {
         });
     });
 
+    describe('Empty allowed IDs edge cases', () => {
+        test('should show "none" as supported metadata IDs when target has no allowed metadata IDs (SPOTTER)', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.SPOTTER,
+                position: CustomActionsPosition.MENU,
+                metadataIds: { liveboardIds: ['lb-1'] },
+            } as any;
+            const result = getCustomActions([action]);
+            // Expect an error containing 'none' for unsupported metadataIds on SPOTTER
+            expect(result.errors.some((e) => e.includes('none'))).toBe(true);
+        });
+
+        test('should show "none" as supported data model IDs when target has no allowed data model IDs (LIVEBOARD)', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+                dataModelIds: { modelIds: ['model-1'] },
+            } as any;
+            const result = getCustomActions([action]);
+            // Expect an error containing 'none' for unsupported dataModelIds on LIVEBOARD
+            expect(result.errors.some((e) => e.includes('none'))).toBe(true);
+        });
+    });
+
     describe('Warnings', () => {
         test('should warn when action name length exceeds 30 characters', () => {
             // Arrange

package/src/utils/graphql/answerService/answerService.spec.ts

@@ -707,4 +707,22 @@ describe('Answer service tests', () => {
         expect(answer.name).toBe('name');
         expect(answer.id).toBe('bar');
     });
+
+    test('getTML parses nested objects and arrays from the YAML edoc', async () => {
+        const edoc = [
+            'answer:',
+            '  name: Revenue answer',
+            '  visualizations:',
+            '    - id: viz-1',
+            '      type: TABLE',
+        ].join('\n');
+        fetchMock.mockResponseOnce(JSON.stringify({
+            data: { UnsavedAnswer_getTML: { object: [{ edoc }] } },
+        }));
+
+        const { answer } = await createAnswerService().getTML();
+
+        expect(answer.name).toBe('Revenue answer');
+        expect(answer.visualizations).toEqual([{ id: 'viz-1', type: 'TABLE' }]);
+    });
 });

package/src/utils/processData.spec.ts

@@ -279,6 +279,38 @@ describe('Unit test for process data', () => {
         mockHandleExitPresentMode.mockReset();
     });
 
+    test('AuthInit with payload.userGUID fallback when data.userGUID is absent', () => {
+        const e = {
+            type: EmbedEvent.AuthInit,
+            payload: { userGUID: 'payloadGUID' },
+        };
+        jest.spyOn(base, 'notifyAuthSuccess');
+        expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
+            type: e.type,
+            payload: { userGUID: 'payloadGUID' },
+            data: { userGUID: 'payloadGUID' },
+        });
+        expect(base.notifyAuthSuccess).toHaveBeenCalled();
+    });
+
+    test('process authFailure EmbeddedSSO with UNAUTHENTICATED_FAILURE suppresses login page', () => {
+        const e = {
+            type: EmbedEvent.AuthFailure,
+            data: { type: auth.AuthFailureType.UNAUTHENTICATED_FAILURE },
+        };
+        jest.spyOn(base, 'notifyAuthFailure');
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
+            loginFailedMessage: 'Hello',
+            authType: AuthType.EmbeddedSSO,
+            disableLoginFailurePage: false,
+        } as any);
+        const el: any = {};
+        processDataInstance.processEventData(e.type, e, '', el);
+        // isEmbeddedSSOInfoFailure=true so neither branch fires, innerHTML stays unset
+        expect(el.innerHTML).toBeUndefined();
+        expect(base.notifyAuthFailure).not.toHaveBeenCalled();
+    });
+
     test('should handle ClearInfoCache', () => {
         const mockResetCachedPreauthInfo = jest.spyOn(sessionInfoService, 'resetCachedPreauthInfo').mockImplementation(() => {});
         const mockResetCachedSessionInfo = jest.spyOn(sessionInfoService, 'resetCachedSessionInfo').mockImplementation(() => {});

package/src/utils/reporting.spec.ts

@@ -88,4 +88,31 @@ describe('ReportingObserver', () => {
 
         (window as any).ReportingObserver = currentObserver;
     });
+
+    test('should suppress alert but still log error when suppressErrorAlerts is true', () => {
+        let callBackPassed: any;
+        const NewMockRO = jest.fn().mockImplementation((callback: any) => {
+            callBackPassed = callback;
+            return ({ observe: jest.fn(), disconnect: jest.fn(), takeRecords: jest.fn() });
+        });
+        const currentObserver = (window as any).ReportingObserver;
+        (window as any).ReportingObserver = NewMockRO;
+
+        setEmbedConfig({
+            thoughtSpotHost: 'testHost',
+            authType: AuthType.None,
+            suppressErrorAlerts: true,
+        } as any);
+
+        const mockAlert = jest.fn();
+        window.alert = mockAlert;
+
+        registerReportingObserver(true);
+        callBackPassed([{ type: 'csp-violation', url: 'testHost', body: { effectiveDirective: 'frame-ancestors' } }]);
+
+        expect(mockAlert).not.toHaveBeenCalled();
+        expect(logger.error).toHaveBeenCalledWith(ERROR_MESSAGE.CSP_FRAME_HOST_VIOLATION_LOG_MESSAGE);
+
+        (window as any).ReportingObserver = currentObserver;
+    });
 });

package/src/utils/sessionInfoService.spec.ts

@@ -0,0 +1,151 @@
+import * as authServiceModule from './authService';
+import * as embedConfigModule from '../embed/embedConfig';
+import {
+    formatPreauthInfo,
+    getPreauthInfo,
+    getSessionInfo,
+    resetCachedPreauthInfo,
+    resetCachedSessionInfo,
+    getCachedSessionInfo,
+    getSessionDetails,
+} from './sessionInfoService';
+
+describe('sessionInfoService', () => {
+    beforeEach(() => {
+        resetCachedPreauthInfo();
+        resetCachedSessionInfo();
+        jest.clearAllMocks();
+    });
+
+    describe('formatPreauthInfo', () => {
+        it('parses headers and JSON body from a response', async () => {
+            const headers = new Headers({ 'content-type': 'application/json' });
+            const mockResp = {
+                headers,
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'u1' } }),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result.info.userGUID).toBe('u1');
+            expect(result.status).toBe(200);
+            expect(result.headers['content-type']).toBe('application/json');
+        });
+
+        it('returns null when response.json() throws (covers catch block)', async () => {
+            const mockResp = {
+                headers: null as any,
+                json: jest.fn().mockRejectedValue(new Error('parse error')),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result).toBeNull();
+        });
+
+        it('handles response where headers is null (covers headers?.forEach branch)', async () => {
+            const mockResp = {
+                headers: null as any,
+                json: jest.fn().mockResolvedValue({ info: {} }),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result.headers).toEqual({});
+        });
+    });
+
+    describe('getPreauthInfo', () => {
+        it('fetches and caches preauthInfo on first call', async () => {
+            const mockResp = {
+                headers: new Headers({ 'x-caller': 'test' }),
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'u1' } }),
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockResolvedValue(mockResp as any);
+
+            const result = await getPreauthInfo();
+            expect(result.info.userGUID).toBe('u1');
+        });
+
+        it('returns cached preauthInfo on subsequent calls (covers allowCache=true && preauthInfo cached branch)', async () => {
+            const mockResp = {
+                headers: new Headers(),
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'cached-user' } }),
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            const fetchSpy = jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockResolvedValue(mockResp as any);
+
+            await getPreauthInfo(); // first call — fetches and caches
+            await getPreauthInfo(); // second call — should use cache
+
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+        });
+
+        it('returns null when fetch throws (covers catch block)', async () => {
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockRejectedValue(new Error('network error'));
+
+            const result = await getPreauthInfo();
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getSessionInfo', () => {
+        it('fetches and returns session info', async () => {
+            const sessionInfoResp = {
+                userGUID: 'u1',
+                releaseVersion: '1.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev', prodSdkKey: 'prod', production: false },
+                    isPublicUser: false,
+                    selfClusterId: 'c1',
+                    selfClusterName: 'cluster1',
+                },
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchSessionInfoService').mockResolvedValue(sessionInfoResp as any);
+
+            const result = await getSessionInfo();
+            expect(result.userGUID).toBe('u1');
+            expect(result.mixpanelToken).toBe('dev');
+        });
+
+        it('returns cached session info on second call', async () => {
+            const sessionInfoResp = {
+                userGUID: 'u2',
+                releaseVersion: '2.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev2', prodSdkKey: 'prod2', production: true },
+                    isPublicUser: false,
+                    selfClusterId: 'c2',
+                    selfClusterName: 'cluster2',
+                },
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            const fetchSpy = jest.spyOn(authServiceModule, 'fetchSessionInfoService').mockResolvedValue(sessionInfoResp as any);
+
+            await getSessionInfo();
+            await getSessionInfo();
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('getCachedSessionInfo', () => {
+        it('returns null before any fetch', () => {
+            expect(getCachedSessionInfo()).toBeNull();
+        });
+    });
+
+    describe('getSessionDetails', () => {
+        it('uses prodSdkKey when production flag is true', () => {
+            const resp = {
+                userGUID: 'u3',
+                releaseVersion: '3.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev', prodSdkKey: 'prod', production: true },
+                    isPublicUser: true,
+                    selfClusterId: 'c3',
+                    selfClusterName: 'cluster3',
+                },
+            };
+            const result = getSessionDetails(resp);
+            expect(result.mixpanelToken).toBe('prod');
+            expect(result.isPublicUser).toBe(true);
+        });
+    });
+});