@thoughtspot/visual-embed-sdk 1.53.0 → 1.53.1

package/src/embed/conversation.spec.ts

@@ -795,6 +795,30 @@ describe('SpotterEmbed APP_INIT embedParams', () => {
         ).toEqual(spotterChatPinConfig);
     });
 
+    it('should send enableConnectorMarketplace in embedParams.spotterSidebarConfig, not the URL', async () => {
+        const response = await getAppInitResponse({
+            worksheetId: 'ws1',
+            spotterSidebarConfig: {
+                enableConnectorMarketplace: true,
+            },
+        });
+        expect(response.data.embedParams.spotterSidebarConfig.enableConnectorMarketplace).toBe(true);
+        expect(getIFrameSrc()).not.toContain('enableConnectorMarketplace');
+    });
+
+    it('should send enableSpotterInstructionAndMoreSettings at the top level of embedParams', async () => {
+        const response = await getAppInitResponse({
+            worksheetId: 'ws1',
+            spotterSidebarConfig: {
+                enablePastConversationsSidebar: true,
+                enableSpotterInstructionAndMoreSettings: true,
+            },
+        });
+        expect(response.data.embedParams.enableSpotterInstructionAndMoreSettings).toBe(true);
+        expect(response.data.embedParams.spotterSidebarConfig)
+            .not.toHaveProperty('enableSpotterInstructionAndMoreSettings');
+    });
+
     it('should populate enablePastConversationsSidebar from deprecated standalone flag', async () => {
         const response = await getAppInitResponse({
             worksheetId: 'ws1',

package/src/embed/conversation.ts

@@ -152,6 +152,19 @@ export interface SpotterSidebarViewConfig {
      * @default Analysts
      */
     spotterAnalystsLabel?: string;
+    /**
+     * Shows the connector marketplace option in the settings menu of the
+     * Spotter sidebar footer. When not set, the cluster setting applies.
+     * @version SDK: 1.53.0 | ThoughtSpot Cloud: 26.10.0.cl
+     */
+    enableConnectorMarketplace?: boolean;
+    /**
+     * Shows the Spotter instructions and more settings options in the
+     * settings menu of the Spotter sidebar footer.
+     * @version SDK: 1.53.0 | ThoughtSpot Cloud: 26.10.0.cl
+     * @default false
+     */
+    enableSpotterInstructionAndMoreSettings?: boolean;
 }
 
 /**
@@ -822,6 +835,7 @@ export interface SpotterAppInitData extends DefaultAppInitData {
         visualOverridesParams?: VisualizationOverrides | null;
         starterPrompts?: StarterPromptsConfig;
         spotterAnalystConfig?: SpotterAnalystConfig;
+        enableSpotterInstructionAndMoreSettings?: boolean;
     };
 }
 

package/src/embed/host-events.spec.ts

@@ -636,6 +636,50 @@ describe('HostEvent.Edit', () => {
     });
 });
 
+// ---------------------------------------------------------------------------
+// ExitEditMode
+// ---------------------------------------------------------------------------
+describe('HostEvent.ExitEditMode', () => {
+    test("enum value is 'exitEditMode' (wire contract with the host app)", () => {
+        expect(HostEvent.ExitEditMode).toBe('exitEditMode');
+    });
+
+    test("postMessage type is 'exitEditMode' (camelCase)", async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard();
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.ExitEditMode);
+            expect(iframe.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({ type: 'exitEditMode' }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+    });
+
+    test('viewConfig.vizId is injected into the payload as data.vizId', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard({ vizId });
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.ExitEditMode, {} as any);
+            expect(iframe.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: 'exitEditMode',
+                    data: expect.objectContaining({ vizId }),
+                }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+    });
+
+    test('returns null when !isRendered', async () => {
+        const lb = unrenderedLiveboard();
+        const result = await lb.trigger(HostEvent.ExitEditMode);
+        expect(result).toBeNull();
+    });
+});
+
 // ---------------------------------------------------------------------------
 // 30 – CopyLink (maps to 'embedDocument')
 // ---------------------------------------------------------------------------

package/src/embed/liveboard.spec.ts

@@ -158,6 +158,25 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should hide and disable the Cancel button in the Liveboard edit header', async () => {
+        expect(Action.Cancel).toBe('cancel');
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            hiddenActions: [Action.Cancel],
+            disabledActions: [Action.Cancel],
+            disabledActionReason: 'Save your changes to leave edit mode',
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                hideAction: JSON.stringify([Action.ReportError, Action.Cancel]),
+                disableAction: JSON.stringify([Action.Cancel]),
+                disableHint: 'Save your changes to leave edit mode',
+            });
+        });
+    });
+
     test('should hide and disable the Spotter button on the Liveboard header', async () => {
         expect(Action.SpotterOnLiveboard).toBe('spotterOnLiveboard');
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -2832,6 +2851,98 @@ describe('Liveboard/viz embed tests', () => {
             expect(navigateToLiveboardSpy).toHaveBeenCalled();
         });
 
+        test('should not route via home when a new instance shows an equal config', async () => {
+            const viewConfig = {
+                liveboardId,
+                vizId,
+                activeTabId,
+                ...defaultViewConfig,
+            };
+            const previous = new LiveboardEmbed(getRootEl(), { ...viewConfig, beforeRender: () => {} } as any);
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), { ...viewConfig, beforeRender: () => {} } as any);
+
+            // React constructs a new embed on every mount.
+            jest.spyOn(liveboardEmbed as any, 'getPreRenderObj').mockReturnValue(previous);
+            const triggerSpy = jest
+                .spyOn(liveboardEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined as any));
+            const navigateToLiveboardSpy = jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForPreRenderNavigate();
+
+            expect(triggerSpy).not.toHaveBeenCalledWith(HostEvent.Navigate, 'home');
+            expect(navigateToLiveboardSpy).toHaveBeenCalled();
+        });
+
+        test('should not route via home when the previous instance has been shown once', async () => {
+            // navigateToLiveboard assigns vizId/activeTabId/personalizedViewId
+            // unconditionally, so a shown instance carries them as undefined
+            // while a fresh one lacks the keys entirely. Comparing raw objects
+            // counts own keys, so it never matches again.
+            const viewConfig = { liveboardId, ...defaultViewConfig };
+            const previous = new LiveboardEmbed(getRootEl(), { ...viewConfig } as any);
+            (previous as any).viewConfig.vizId = undefined;
+            (previous as any).viewConfig.activeTabId = undefined;
+            (previous as any).viewConfig.personalizedViewId = undefined;
+
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), { ...viewConfig } as any);
+
+            jest.spyOn(liveboardEmbed as any, 'getPreRenderObj').mockReturnValue(previous);
+            const triggerSpy = jest
+                .spyOn(liveboardEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined as any));
+            jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForPreRenderNavigate();
+
+            expect(triggerSpy).not.toHaveBeenCalledWith(HostEvent.Navigate, 'home');
+        });
+
+        test('should route via home when a new instance shows the same route with other filters', async () => {
+            const viewConfig = {
+                liveboardId,
+                vizId,
+                activeTabId,
+                ...defaultViewConfig,
+            };
+            const previous = new LiveboardEmbed(getRootEl(), {
+                ...viewConfig,
+                runtimeFilters: [{ columnName: 'region', operator: RuntimeFilterOp.EQ, values: ['east'] }],
+            });
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                ...viewConfig,
+                runtimeFilters: [{ columnName: 'region', operator: RuntimeFilterOp.EQ, values: ['west'] }],
+            });
+
+            jest.spyOn(liveboardEmbed as any, 'getPreRenderObj').mockReturnValue(previous);
+            const triggerSpy = jest
+                .spyOn(liveboardEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined as any));
+            jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForHomeHopNavigate();
+
+            expect(triggerSpy).toHaveBeenCalledWith(HostEvent.Navigate, 'home');
+        });
+
         test('should not route via home when the pre-render is on another liveboard', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 liveboardId,

package/src/embed/liveboard.ts

@@ -8,6 +8,7 @@
  * @author Ayon Ghosh <ayon.ghosh@thoughtspot.com>
  */
 
+import isEqualWith from 'lodash/isEqualWith';
 import { getPreview } from '../utils/graphql/preview-service';
 import { ERROR_MESSAGE } from '../errors';
 import {
@@ -605,6 +606,14 @@ export interface LiveboardViewConfig
  * })
  * ```
  */
+/**
+ * A shallow copy without the keys whose value is `undefined`, so a key that was
+ * assigned `undefined` compares equal to one that was never set.
+ */
+const definedEntries = (config: Record<string, any> = {}): Record<string, any> => Object.fromEntries(
+    Object.entries(config).filter(([, value]) => value !== undefined),
+);
+
 export class LiveboardEmbed extends V1Embed {
     protected viewConfig: LiveboardViewConfig;
 
@@ -1004,17 +1013,19 @@ export class LiveboardEmbed extends V1Embed {
         super.beforePrerenderVisible();
 
         // Captured before showPreRender() hands the wrapper over to this
-        // instance. Itself means a hide/show, not a hand-over, so there is
-        // nothing stale to clear.
+        // instance. React builds a new instance per mount, so an equal config
+        // is a hide/show, not a hand-over: there is nothing stale to clear.
         const previous = this.getPreRenderObj<LiveboardEmbed>();
-        const showing = previous === this ? undefined : previous?.currentLiveboardState;
+        const previousRoute = this.isSameEmbedConfig(previous)
+            ? undefined
+            : previous?.currentLiveboardState;
 
         this.executeAfterEmbedContainerLoaded(async () => {
             // Without this the params callback suspends on its await and
             // Navigate goes out first, so the container loads with the previous
             // config's filters.
             await this.preRenderParamsApplied;
-            if (this.isShowingLiveboardRoute(showing)) {
+            if (this.isAlreadyOnSameRoute(previousRoute)) {
                 // Navigate to the route we are already on is a no-op, so the
                 // liveboard keeps its state. Home unmounts the container, which
                 // clears it.
@@ -1041,18 +1052,31 @@ export class LiveboardEmbed extends V1Embed {
         });
     }
 
+    // definedEntries drops undefined-valued keys: a shown instance carries
+    // vizId/activeTabId/etc as undefined, so a raw isEqual never matches again.
+    // Functions compare equal, since React passes a fresh closure per render.
+    private isSameEmbedConfig(previous?: LiveboardEmbed): boolean {
+        if (!previous) return false;
+        if (previous === this) return true;
+        return isEqualWith(
+            definedEntries(previous.viewConfig),
+            definedEntries(this.viewConfig),
+            (a, b) => (typeof a === 'function' && typeof b === 'function' ? true : undefined),
+        );
+    }
+
     // The whole route, not just the liveboard id: the path is built from the
     // viz, tab and view too, so a same-liveboard show onto another tab is a
     // real navigation.
-    private isShowingLiveboardRoute(showing?: LiveboardEmbed['currentLiveboardState']): boolean {
-        if (!showing?.liveboardId) return false;
+    private isAlreadyOnSameRoute(previousRoute?: LiveboardEmbed['currentLiveboardState']): boolean {
+        if (!previousRoute?.liveboardId) return false;
         const {
             liveboardId, vizId, activeTabId, personalizedViewId,
         } = this.viewConfig;
-        return showing.liveboardId === liveboardId
-            && showing.vizId === vizId
-            && showing.activeTabId === activeTabId
-            && showing.personalizedViewId === personalizedViewId;
+        return previousRoute.liveboardId === liveboardId
+            && previousRoute.vizId === vizId
+            && previousRoute.activeTabId === activeTabId
+            && previousRoute.personalizedViewId === personalizedViewId;
     }
 
     protected async handleRenderForPrerender(): Promise<TsEmbed> {

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

@@ -58,6 +58,26 @@ describe('buildSpotterSidebarAppInitData', () => {
             .toEqual(spotterChatPinConfig);
     });
 
+    it('lifts enableSpotterInstructionAndMoreSettings to the top level of embedParams', () => {
+        const result = buildSpotterSidebarAppInitData(base, {
+            spotterSidebarConfig: {
+                enablePastConversationsSidebar: true,
+                enableSpotterInstructionAndMoreSettings: false,
+            },
+        }, noopError);
+        expect(result.embedParams?.enableSpotterInstructionAndMoreSettings).toBe(false);
+        expect(result.embedParams?.spotterSidebarConfig).toEqual({
+            enablePastConversationsSidebar: true,
+        });
+    });
+
+    it('omits enableSpotterInstructionAndMoreSettings when it is not set', () => {
+        const result = buildSpotterSidebarAppInitData(base, {
+            spotterSidebarConfig: { enablePastConversationsSidebar: true },
+        }, noopError);
+        expect(result.embedParams).not.toHaveProperty('enableSpotterInstructionAndMoreSettings');
+    });
+
     it('promotes standalone flag into spotterSidebarConfig.enablePastConversationsSidebar', () => {
         const result = buildSpotterSidebarAppInitData(base, { enablePastConversationsSidebar: true }, noopError);
         expect(result.embedParams?.spotterSidebarConfig?.enablePastConversationsSidebar).toBe(true);

package/src/embed/spotter-utils.ts

@@ -36,6 +36,7 @@ export function buildSpotterSidebarAppInitData<T extends DefaultAppInitData>(
     embedParams?: {
         spotterSidebarConfig?: SpotterSidebarViewConfig;
         visualOverridesParams?: VisualizationOverrides | null;
+        enableSpotterInstructionAndMoreSettings?: boolean;
     };
 } {
     const { spotterSidebarConfig, enablePastConversationsSidebar, visualOverrides } = viewConfig;
@@ -56,8 +57,15 @@ export function buildSpotterSidebarAppInitData<T extends DefaultAppInitData>(
         };
     }
 
+    // The app reads enableSpotterInstructionAndMoreSettings from the top level
+    // of embedParams, so lift it out of the sidebar config.
+    const {
+        enableSpotterInstructionAndMoreSettings,
+        ...sidebarConfigRest
+    } = spotterSidebarConfig || {};
+
     const resolvedSidebarConfig: SpotterSidebarViewConfig = {
-        ...spotterSidebarConfig,
+        ...sidebarConfigRest,
         ...(resolvedEnablePastConversations !== undefined && {
             enablePastConversationsSidebar: resolvedEnablePastConversations,
         }),
@@ -81,6 +89,9 @@ export function buildSpotterSidebarAppInitData<T extends DefaultAppInitData>(
         embedParams: {
             ...((defaultAppInitData as any).embedParams || {}),
             spotterSidebarConfig: resolvedSidebarConfig,
+            ...(enableSpotterInstructionAndMoreSettings !== undefined
+                ? { enableSpotterInstructionAndMoreSettings }
+                : {}),
             ...(visualOverrides !== undefined ? { visualOverridesParams: visualOverrides } : {}),
         },
     };