@thoughtspot/visual-embed-sdk 1.52.2-beta.0 → 1.52.2-beta.2

package/lib/src/visual-embed-sdk.d.ts

@@ -15672,21 +15672,6 @@ export interface LiveboardViewConfig extends BaseViewConfig, FullHeightViewConfi
 	 */
 	updatedSpotterExperience?: boolean;
 }
-/**
- * Embed a ThoughtSpot Liveboard or visualization. When rendered it already
- * waits for the authentication to complete, so you need not wait for
- * `AuthStatus.SUCCESS`.
- * @group Embed components
- * @example
- * ```js
- * import { .. } from '@thoughtspot/visual-embed-sdk';
- * init({ ... });
- * const embed = new LiveboardEmbed("#container", {
- *   liveboardId: <your-id-here>,
- * // .. other params here.
- * })
- * ```
- */
 export class LiveboardEmbed extends V1Embed {
 	protected viewConfig: LiveboardViewConfig;
 	private readonly fullHeightController?;
@@ -15718,6 +15703,19 @@ export class LiveboardEmbed extends V1Embed {
 		personalizedViewId: string;
 	};
 	protected beforePrerenderVisible(): void;
+	/**
+	 * Whether `previous` was showing what this instance is about to show.
+	 *
+	 * Undefined-valued keys are dropped before comparing. `navigateToLiveboard`
+	 * assigns `vizId`, `activeTabId` and `personalizedViewId` unconditionally,
+	 * so an instance that has been shown once carries those keys as `undefined`
+	 * while a freshly constructed one does not have them at all. `isEqual`
+	 * counts own keys, so without this the comparison can never be true after
+	 * the first show — which is the whole case this exists for.
+	 *
+	 * Callbacks compare as equal: React passes a fresh closure per render.
+	 */
+	private isSameEmbedConfig;
 	private isShowingLiveboardRoute;
 	protected handleRenderForPrerender(): Promise<TsEmbed>;
 	/**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thoughtspot/visual-embed-sdk",
-    "version": "1.52.2-beta.0",
+    "version": "1.52.2-beta.2",
     "description": "ThoughtSpot Embed SDK",
     "module": "lib/src/index.js",
     "main": "dist/tsembed.js",

package/src/embed/liveboard.spec.ts

@@ -2748,6 +2748,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 {
@@ -562,6 +563,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;
 
@@ -955,10 +964,12 @@ 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 showing = this.isSameEmbedConfig(previous)
+            ? undefined
+            : previous?.currentLiveboardState;
 
         this.executeAfterEmbedContainerLoaded(async () => {
             // Without this the params callback suspends on its await and
@@ -992,6 +1003,28 @@ export class LiveboardEmbed extends V1Embed {
         });
     }
 
+    /**
+     * Whether `previous` was showing what this instance is about to show.
+     *
+     * Undefined-valued keys are dropped before comparing. `navigateToLiveboard`
+     * assigns `vizId`, `activeTabId` and `personalizedViewId` unconditionally,
+     * so an instance that has been shown once carries those keys as `undefined`
+     * while a freshly constructed one does not have them at all. `isEqual`
+     * counts own keys, so without this the comparison can never be true after
+     * the first show — which is the whole case this exists for.
+     *
+     * Callbacks compare as equal: 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.

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

@@ -71,10 +71,6 @@ import * as processData from '../utils/processData';
 jest.mock('../utils/processTrigger');
 
 const mockProcessTrigger = processTrigger as jest.Mock;
-
-const flushAnimationFrame = () => new Promise<void>((resolve) => {
-    requestAnimationFrame(() => resolve());
-});
 const mockHandleInterceptEvent = jest.spyOn(apiIntercept, 'handleInterceptEvent');
 const defaultViewConfig = {
     frameParams: {
@@ -2624,9 +2620,6 @@ describe('Unit test case for ts embed', () => {
                     contentRect: { height: 297, width: 987 },
                 },
             ]);
-            // Syncs are coalesced to one per frame.
-            await flushAnimationFrame();
-
             expect(preRenderWrapper.style.height).toEqual(`${297}px`);
             expect(preRenderWrapper.style.width).toEqual(`${987}px`);
 
@@ -2887,28 +2880,28 @@ describe('Unit test case for ts embed', () => {
                 return placeholder;
             };
 
-            it('should stop tracking once the frame is hidden', async () => {
-                const { scroller, readPlaceholderTop } = mountInNestedScroller();
+            it('should stop observing the placeholder once the frame is hidden', async () => {
+                const { scroller } = mountInNestedScroller();
 
                 const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'scroll-stops-on-hide',
+                    preRenderId: 'observer-stops-on-hide',
                     liveboardId: 'myLiveboardId',
                 });
                 libEmbed.preRender();
                 await waitFor(() => !!getIFrameEl());
                 await libEmbed.showPreRender();
 
-                stubPlaceholderRect(libEmbed, readPlaceholderTop);
-                libEmbed.hidePreRender();
+                // Size is the only thing the browser will not handle for us, so
+                // the observer is the one live resource a hide has to release.
+                const observer = (libEmbed as any).resizeObserver;
+                expect(observer).toBeDefined();
+                const disconnectSpy = jest.spyOn(observer, 'disconnect');
 
-                const syncSpy = jest.spyOn(libEmbed, 'syncPreRenderStyle');
-                scroller.scrollTop = 250;
-                scroller.dispatchEvent(new Event('scroll'));
-                await flushAnimationFrame();
+                libEmbed.hidePreRender();
 
-                expect(syncSpy).not.toHaveBeenCalled();
+                expect(disconnectSpy).toHaveBeenCalled();
 
-                syncSpy.mockRestore();
+                disconnectSpy.mockRestore();
                 libEmbed.destroy();
                 scroller.remove();
             });