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

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

@@ -53,6 +53,7 @@ import {
 import * as config from '../config';
 import * as embedConfig from './embedConfig';
 import * as tsEmbedInstance from './ts-embed';
+import { BOOTSTRAP_URL_PARAMS } from './ts-embed';
 import * as mixpanelInstance from '../mixpanel-service';
 import * as authInstance from '../auth';
 import * as baseInstance from './base';
@@ -1312,6 +1313,34 @@ describe('Unit test case for ts embed', () => {
             );
         });
 
+        test('should send visual-sdk-init-actions with configured actions, [] when unused', async () => {
+            await new SearchEmbed(getRootEl(), {
+                hiddenActions: [Action.Download],
+                disabledActions: [Action.Edit],
+            }).render();
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(
+                MIXPANEL_EVENT.VISUAL_SDK_INIT_ACTIONS,
+                expect.objectContaining({
+                    hiddenActions: [Action.Download],
+                    visibleActions: [],
+                    disabledActions: [Action.Edit],
+                }),
+            );
+
+            mockMixPanelEvent.mockClear();
+            await new SearchEmbed(getRootEl(), {
+                visibleActions: [Action.Save],
+            }).render();
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(
+                MIXPANEL_EVENT.VISUAL_SDK_INIT_ACTIONS,
+                expect.objectContaining({
+                    hiddenActions: [],
+                    visibleActions: [Action.Save],
+                    disabledActions: [],
+                }),
+            );
+        });
+
         test('Should remove prefetch iframe', async () => {
             await setup(true);
             const prefetchIframe = document.querySelectorAll<HTMLIFrameElement>('.prefetchIframe');
@@ -2549,6 +2578,85 @@ describe('Unit test case for ts embed', () => {
         });
     });
 
+    describe('isDarkMode', () => {
+        const renderAppEmbed = async (viewConfig = {}) => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                ...viewConfig,
+            });
+            appEmbed.render();
+            await waitFor(() => !!getIFrameEl());
+            return getIFrameSrc();
+        };
+
+        it('sends the appearance the host asked for in init, with the radiant theme', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+                isDarkMode: true,
+            });
+
+            expectUrlToHaveParamsWithValues(await renderAppEmbed(), {
+                isDarkMode: true,
+                radiantThemeEnabled: true,
+            });
+        });
+
+        it('sends an explicit false', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+                isDarkMode: false,
+            });
+
+            const src = await renderAppEmbed();
+            expectUrlToHaveParamsWithValues(src, { isDarkMode: false });
+            // `false` leaves the radiant theme to the cluster.
+            expect(src).not.toContain('radiantThemeEnabled=');
+        });
+
+        it('omits the param when the host says nothing', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+            });
+
+            // Absent rather than `isDarkMode=false`: an omitted param keeps the
+            // URL short, and the app treats a missing param like `false`.
+            const src = await renderAppEmbed();
+            expect(src).not.toContain('isDarkMode=');
+            expect(src).not.toContain('radiantThemeEnabled=');
+        });
+
+        it('lets the view config override the value set in init', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+                isDarkMode: true,
+            });
+
+            const src = await renderAppEmbed({ isDarkMode: false });
+            expectUrlToHaveParamsWithValues(src, { isDarkMode: false });
+            expect(src).not.toContain('radiantThemeEnabled=');
+        });
+
+        it('lets additionalFlags override the radiant theme it turns on', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+                isDarkMode: true,
+            });
+
+            expectUrlToHaveParamsWithValues(
+                await renderAppEmbed({ additionalFlags: { radiantThemeEnabled: false } }),
+                { isDarkMode: true, radiantThemeEnabled: false },
+            );
+        });
+    });
+
     describe('validate preRender flow', () => {
         beforeAll(() => {
             init({
@@ -2620,11 +2728,12 @@ describe('Unit test case for ts embed', () => {
                     contentRect: { height: 297, width: 987 },
                 },
             ]);
+
             expect(preRenderWrapper.style.height).toEqual(`${297}px`);
             expect(preRenderWrapper.style.width).toEqual(`${987}px`);
 
             expect(preRenderWrapper.style.opacity).toBe('');
-            expect(preRenderWrapper.style.pointerEvents).toBe('auto');
+            expect(preRenderWrapper.style.pointerEvents).toBe('');
             expect(preRenderWrapper.style.zIndex).toBe('');
 
             libEmbed.hidePreRender();
@@ -2661,7 +2770,7 @@ describe('Unit test case for ts embed', () => {
             const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
 
             expect(preRenderWrapper.style.opacity).toBe('');
-            expect(preRenderWrapper.style.pointerEvents).toBe('auto');
+            expect(preRenderWrapper.style.pointerEvents).toBe('');
             expect(preRenderWrapper.style.zIndex).toBe('');
         });
 
@@ -2834,211 +2943,6 @@ describe('Unit test case for ts embed', () => {
             (logger.debug as any).mockRestore();
         });
 
-        describe('position tracking (SCAL-338563)', () => {
-            /**
-             * A host app whose page scrolls in an inner element rather than the
-             * document — the shape both reported cases have. The placeholder's
-             * rect is driven off that element's scrollTop, the way a real
-             * layout would move it.
-             */
-            const mountInNestedScroller = () => {
-                createRootEleForEmbed();
-                const scroller = document.createElement('div');
-                scroller.id = 'inner-scroller';
-                document.body.appendChild(scroller);
-                scroller.appendChild(document.getElementById('tsEmbedDiv'));
-
-                let scrollTop = 0;
-                Object.defineProperty(scroller, 'scrollTop', {
-                    configurable: true,
-                    get: () => scrollTop,
-                    set: (value) => {
-                        scrollTop = value;
-                    },
-                });
-                scroller.getBoundingClientRect = () =>
-                    ({
-                        x: 0, y: 0, width: 800, height: 600,
-                        top: 0, left: 0, bottom: 600, right: 800,
-                    } as DOMRect);
-
-                const placeholderTopAtRest = 400;
-                const readPlaceholderTop = () => placeholderTopAtRest - scroller.scrollTop;
-
-                return { scroller, readPlaceholderTop };
-            };
-
-            const stubPlaceholderRect = (embed: any, readTop: () => number) => {
-                const placeholder = embed.getPreRenderPlaceHolderElement() as HTMLElement;
-                placeholder.getBoundingClientRect = () => {
-                    const top = readTop();
-                    return {
-                        x: 0, y: top, width: 800, height: 300,
-                        top, left: 0, bottom: top + 300, right: 800,
-                    } as DOMRect;
-                };
-                return placeholder;
-            };
-
-            it('should stop observing the placeholder once the frame is hidden', async () => {
-                const { scroller } = mountInNestedScroller();
-
-                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'observer-stops-on-hide',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await waitFor(() => !!getIFrameEl());
-                await libEmbed.showPreRender();
-
-                // 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');
-
-                libEmbed.hidePreRender();
-
-                expect(disconnectSpy).toHaveBeenCalled();
-
-                disconnectSpy.mockRestore();
-                libEmbed.destroy();
-                scroller.remove();
-            });
-
-            it('should default the container to the host scrolling ancestor', async () => {
-                const { scroller } = mountInNestedScroller();
-                scroller.style.overflowY = 'auto';
-
-                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'auto-scroll-container',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await waitFor(() => !!getIFrameEl());
-                await libEmbed.showPreRender();
-
-                const wrapper = document.getElementById(libEmbed.getPreRenderIds().wrapper);
-                // In the scroller, so the browser moves it — no repositioning.
-                expect(wrapper.parentElement).toBe(scroller);
-                expect((libEmbed as any).preRenderContainerEl).toBe(scroller);
-
-                libEmbed.destroy();
-                scroller.remove();
-            });
-
-            it('should still use document.body when nothing scrolls', async () => {
-                createRootEleForEmbed();
-
-                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'no-scroller-body',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await waitFor(() => !!getIFrameEl());
-                await libEmbed.showPreRender();
-
-                const wrapper = document.getElementById(libEmbed.getPreRenderIds().wrapper);
-                expect(wrapper.parentElement).toBe(document.body);
-
-                libEmbed.destroy();
-            });
-
-            it('should set pointer-events on show rather than dropping the property', async () => {
-                createRootEleForEmbed();
-                const container = document.createElement('div');
-                container.id = 'parking-root';
-                // Usual styling for a parking root: no swallowed clicks.
-                container.style.pointerEvents = 'none';
-                document.body.appendChild(container);
-
-                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'pointer-events-restored',
-                    liveboardId: 'myLiveboardId',
-                    preRenderContainer: '#parking-root',
-                });
-                libEmbed.preRender();
-                await waitFor(() => !!getIFrameEl());
-                await libEmbed.showPreRender();
-
-                const wrapper = document.getElementById(libEmbed.getPreRenderIds().wrapper);
-                // Merely removing the property would leave the container's
-                // inherited `none` in force, and the frame dead to input.
-                expect(wrapper.style.pointerEvents).toBe('auto');
-
-                libEmbed.destroy();
-                container.remove();
-            });
-
-            it('should park a hidden wrapper out of the scrollable area', async () => {
-                createRootEleForEmbed();
-
-                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'hidden-parked',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await waitFor(() => !!getIFrameEl());
-                await libEmbed.showPreRender();
-
-                const wrapper = document.getElementById(libEmbed.getPreRenderIds().wrapper);
-                expect(wrapper.style.transform).toBe('');
-
-                libEmbed.hidePreRender();
-                expect(wrapper.style.transform).toBe('translateY(-100%)');
-
-                await libEmbed.showPreRender();
-                expect(wrapper.style.transform).toBe('');
-
-                libEmbed.destroy();
-            });
-
-            it('should not seed the placeholder with the unmeasured wrapper height', async () => {
-                createRootEleForEmbed();
-
-                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'unmeasured-height',
-                    liveboardId: 'myLiveboardId',
-                    fullHeight: true,
-                    frameParams: { height: 420 },
-                });
-                libEmbed.preRender();
-                await waitFor(() => !!getIFrameEl());
-
-                const wrapper = document.getElementById(libEmbed.getPreRenderIds().wrapper);
-                // createPreRenderWrapper() seeds 100vh, not a measurement.
-                expect(wrapper.style.height).toBe('100vh');
-
-                await libEmbed.showPreRender();
-
-                const placeholder = (libEmbed as any).getPreRenderPlaceHolderElement() as HTMLElement;
-                expect(placeholder.style.height).toBe('420px');
-
-                libEmbed.destroy();
-            });
-
-            it('should seed the placeholder with a height fullHeight has measured', async () => {
-                createRootEleForEmbed();
-
-                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'measured-height',
-                    liveboardId: 'myLiveboardId',
-                    fullHeight: true,
-                    frameParams: { height: 420 },
-                });
-                libEmbed.preRender();
-                await waitFor(() => !!getIFrameEl());
-
-                (libEmbed as any).setIFrameHeight(1180);
-                await libEmbed.showPreRender();
-
-                const placeholder = (libEmbed as any).getPreRenderPlaceHolderElement() as HTMLElement;
-                expect(placeholder.style.height).toBe('1180px');
-
-                libEmbed.destroy();
-            });
-        });
-
         describe('preRenderContainer', () => {
             it('should append preRenderWrapper to document.body when preRenderContainer is not set', async () => {
                 createRootEleForEmbed();
@@ -3312,16 +3216,21 @@ describe('Unit test case for ts embed', () => {
 
                 // Simulate React remounting the container: the old node (with
                 // our wrapper) is detached and a fresh node takes its place.
+                const removeSpy = jest.spyOn(oldContainer, 'removeEventListener');
                 oldContainer.remove();
                 const newContainer = document.createElement('div');
                 newContainer.id = 'remount-container';
                 document.body.appendChild(newContainer);
+                const addSpy = jest.spyOn(newContainer, 'addEventListener');
 
                 // A reposition (scroll/resize/re-show) heals the stale ref.
                 libEmbed.syncPreRenderStyle();
 
                 expect(newContainer.contains(wrapper)).toBe(true);
                 expect(oldContainer.contains(wrapper)).toBe(false);
+                // The scroll listener is migrated to the live container.
+                expect(removeSpy).toHaveBeenCalledWith('scroll', expect.any(Function));
+                expect(addSpy).toHaveBeenCalledWith('scroll', expect.any(Function));
 
                 libEmbed.destroy();
                 newContainer.remove();
@@ -6894,3 +6803,572 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
     });
 });
+
+describe('excludeConfigFromURL', () => {
+    const lbConfig = {
+        liveboardId,
+        hiddenActions: [Action.Download],
+        additionalFlags: { internalBlinkFlag: true },
+        liveboardV2: true,
+    };
+
+    const withPostMessage = (viewConfig: any) => ({
+        ...viewConfig,
+        additionalFlags: { ...viewConfig.additionalFlags, excludeConfigFromURL: true },
+    });
+
+    const renderAndGetSrc = async (viewConfig: any) => {
+        const embed = new LiveboardEmbed(getRootEl(), { ...defaultViewConfig, ...viewConfig });
+        await embed.render();
+        await waitFor(() => !!getIFrameEl());
+        return { embed, src: getIFrameSrc() };
+    };
+
+    const signalFrameReady = () => {
+        postMessageToParent(getIFrameEl().contentWindow, {
+            type: EmbedEvent.EmbedListenerReady,
+        });
+    };
+
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+        mockProcessTrigger.mockReset();
+        mockProcessTrigger.mockResolvedValue({});
+        init({
+            thoughtSpotHost,
+            authType: AuthType.None,
+        });
+    });
+
+    test('leaves the URL untouched when the flag is not set', async () => {
+        const { src } = await renderAndGetSrc(lbConfig);
+
+        expect(src).toContain('hideAction=');
+        expect(src).toContain('internalBlinkFlag=true');
+        expect(src).toContain('isPinboardV2Enabled=true');
+    });
+
+    test('keeps only the bootstrap params on the URL when the flag is set', async () => {
+        const { src } = await renderAndGetSrc(withPostMessage(lbConfig));
+
+        // Boot and auth handshake stays on the URL.
+        expect(src).toContain('hostAppUrl=');
+        expect(src).toContain(`authType=${AuthType.None}`);
+        expect(src).toContain(`sdkVersion=${version}`);
+        expect(src).toContain('blockNonEmbedFullAppAccess=true');
+        expect(src).toContain('viewPortHeight=');
+
+        // View configuration and internal flags do not.
+        expect(src).not.toContain('hideAction=');
+        expect(src).not.toContain('internalBlinkFlag');
+    });
+
+    describe('BOOTSTRAP_URL_PARAMS', () => {
+        test('keeps the auth and origin params', () => {
+            [Param.EmbedApp, Param.HostAppUrl, Param.Version, Param.AuthType].forEach(
+                (param) => {
+                    expect(BOOTSTRAP_URL_PARAMS.has(param)).toBe(true);
+                },
+            );
+        });
+
+        test('leaves the layout flags to the APP_INIT payload', () => {
+            [
+                Param.LiveboardV2Enabled,
+                Param.PrimaryNavHidden,
+                Param.HideSearchBar,
+                Param.SpotterExperienceVersion,
+            ].forEach((param) => {
+                expect(BOOTSTRAP_URL_PARAMS.has(param)).toBe(false);
+            });
+        });
+    });
+
+    describe('params held back from the URL go in the APP_INIT payload', () => {
+        const renderEmbed = async (EmbedClass: any, viewConfig: any, excludeConfig = true) => {
+            const embed = new EmbedClass(getRootEl(), {
+                ...defaultViewConfig,
+                ...viewConfig,
+                additionalFlags: {
+                    ...viewConfig.additionalFlags,
+                    ...(excludeConfig && { excludeConfigFromURL: true }),
+                },
+            });
+            await embed.render();
+            await waitFor(() => !!getIFrameEl());
+            return embed;
+        };
+
+        const requestAppInit = async (): Promise<any> => {
+            const mockPort: any = { postMessage: jest.fn() };
+            postMessageToParent(
+                getIFrameEl().contentWindow,
+                { type: EmbedEvent.APP_INIT, data: {} },
+                mockPort,
+            );
+            await waitFor(() => mockPort.postMessage.mock.calls.length > 0);
+            return mockPort.postMessage.mock.calls[0][0].data;
+        };
+
+        const getAppInitFor = async (EmbedClass: any, viewConfig: any) => {
+            await renderEmbed(EmbedClass, viewConfig);
+            return requestAppInit();
+        };
+
+        test('sends the app navigation and page version flags', async () => {
+            const { embedParams } = await getAppInitFor(AppEmbed, {
+                showPrimaryNavbar: false,
+                hideHamburger: true,
+                hideNotification: true,
+                hideObjectSearch: true,
+                hideOrgSwitcher: true,
+                hideApplicationSwitcher: true,
+                disableProfileAndHelp: true,
+                hideHomepageLeftNav: true,
+                hideTagFilterChips: true,
+                modularHomeExperience: true,
+                liveboardV2: true,
+            });
+
+            expect(embedParams).toEqual(
+                expect.objectContaining({
+                    [Param.PrimaryNavHidden]: true,
+                    [Param.HideHamburger]: true,
+                    [Param.HideNotification]: true,
+                    [Param.HideObjectSearch]: true,
+                    [Param.HideOrgSwitcher]: true,
+                    [Param.HideApplicationSwitcher]: true,
+                    [Param.HideProfleAndHelp]: true,
+                    [Param.HideHomepageLeftNav]: true,
+                    [Param.HideTagFilterChips]: true,
+                    [Param.ModularHomeExperienceEnabled]: true,
+                    [Param.LiveboardV2Enabled]: true,
+                    [Param.NavigationVersion]: expect.any(String),
+                    [Param.HomepageVersion]: expect.any(String),
+                }),
+            );
+        });
+
+        test('sends the Liveboard layout flags', async () => {
+            const { embedParams } = await getAppInitFor(LiveboardEmbed, {
+                liveboardId,
+                visibleVizs: ['viz-1'],
+                hideLiveboardHeader: true,
+                showLiveboardTitle: true,
+                showLiveboardDescription: true,
+                hideTabPanel: true,
+                enable2ColumnLayout: true,
+                isLiveboardHeaderSticky: true,
+                showLiveboardVerifiedBadge: true,
+            });
+
+            expect(embedParams).toEqual(
+                expect.objectContaining({
+                    [Param.visibleVizs]: ['viz-1'],
+                    [Param.HideLiveboardHeader]: true,
+                    [Param.ShowLiveboardTitle]: true,
+                    [Param.ShowLiveboardDescription]: true,
+                    [Param.HideTabPanel]: true,
+                    [Param.Enable2ColumnLayout]: true,
+                    [Param.LiveboardHeaderSticky]: true,
+                    [Param.ShowLiveboardVerifiedBadge]: true,
+                }),
+            );
+        });
+
+        test('sends the search layout flags and the initial query', async () => {
+            const { embedParams } = await getAppInitFor(SearchEmbed, {
+                dataSource: 'ds-1',
+                searchOptions: {
+                    searchTokenString: '[revenue]',
+                    executeSearch: true,
+                },
+                hideResults: true,
+                hideSearchBar: true,
+                collapseSearchBarInitially: true,
+                enableSearchAssist: true,
+            });
+
+            expect(embedParams).toEqual(
+                expect.objectContaining({
+                    [Param.HideResult]: true,
+                    [Param.HideSearchBar]: true,
+                    [Param.CollapseSearchBarInitially]: true,
+                    [Param.EnableSearchAssist]: true,
+                    [Param.executeSearch]: true,
+                    [Param.DataSourceMode]: expect.anything(),
+                }),
+            );
+            expect(embedParams).not.toHaveProperty(Param.searchTokenString);
+        });
+
+        test('sends the Spotter empty-screen flags', async () => {
+            const { embedParams } = await getAppInitFor(SpotterEmbed, {
+                worksheetId: 'worksheet-1',
+                hideSampleQuestions: true,
+                hideSourceSelection: true,
+                disableSourceSelection: true,
+                showSpotterLimitations: true,
+                showSpotterRadiance: true,
+                updatedSpotterChatPrompt: true,
+                spotterChatConfig: { enableStarterPrompts: true },
+            });
+
+            expect(embedParams).toEqual(
+                expect.objectContaining({
+                    [Param.HideSampleQuestions]: true,
+                    [Param.HideSourceSelection]: true,
+                    [Param.DisableSourceSelection]: true,
+                    [Param.ShowSpotterLimitations]: true,
+                    [Param.ShowSpotterRadiance]: true,
+                    [Param.UpdatedSpotterChatPrompt]: true,
+                    [Param.IsStarterPromptsEnabled]: true,
+                }),
+            );
+        });
+
+        test('sends the action and tab lists and the additionalFlags', async () => {
+            await renderEmbed(LiveboardEmbed, {
+                liveboardId,
+                visibleActions: [Action.Download],
+                visibleTabs: ['tab-1'],
+                additionalFlags: { internalBlinkFlag: true },
+            });
+            const src = getIFrameSrc();
+            const { embedParams } = await requestAppInit();
+
+            expect(src).not.toContain(`${Param.VisibleActions}=`);
+            expect(src).not.toContain(`${Param.VisibleTabs}=`);
+            expect(embedParams).toEqual(
+                expect.objectContaining({
+                    [Param.VisibleActions]: [Action.Download],
+                    [Param.VisibleTabs]: ['tab-1'],
+                    internalBlinkFlag: true,
+                }),
+            );
+        });
+
+        test('sends the feature flags only in embedParams', async () => {
+            const appInitData = await getAppInitFor(AppEmbed, {
+                showPrimaryNavbar: false,
+                liveboardV2: true,
+                dataPanelV2: true,
+            });
+            const featureFlags = {
+                [Param.PrimaryNavHidden]: true,
+                [Param.LiveboardV2Enabled]: true,
+                [Param.DataPanelV2Enabled]: true,
+            };
+
+            // The app overrides its feature flags from embedParams.
+            expect(appInitData.embedParams).toEqual(expect.objectContaining(featureFlags));
+            Object.keys(featureFlags).forEach((flag) => {
+                expect(appInitData).not.toHaveProperty(flag);
+            });
+        });
+
+        test("lets the embed's own embedParams win over a param of the same name", async () => {
+            const { embedParams } = await getAppInitFor(SpotterEmbed, {
+                worksheetId: 'worksheet-1',
+                spotterSidebarConfig: { enablePastConversationsSidebar: true },
+                additionalFlags: { spotterSidebarConfig: 'from-flags' },
+            });
+
+            expect(embedParams.spotterSidebarConfig).toEqual(
+                expect.objectContaining({ enablePastConversationsSidebar: true }),
+            );
+        });
+
+        test("keeps the embed's own embedParams alongside the params", async () => {
+            const { embedParams } = await getAppInitFor(SpotterEmbed, {
+                worksheetId: 'worksheet-1',
+                hideSampleQuestions: true,
+                spotterSidebarConfig: { enablePastConversationsSidebar: true },
+            });
+
+            expect(embedParams).toEqual(
+                expect.objectContaining({
+                    [Param.HideSampleQuestions]: true,
+                    spotterSidebarConfig: expect.objectContaining({
+                        enablePastConversationsSidebar: true,
+                    }),
+                }),
+            );
+        });
+
+        test('keeps the search token on the URL', async () => {
+            const { embedParams } = await getAppInitFor(SearchEmbed, {
+                dataSource: 'ds-1',
+                searchOptions: { searchTokenString: '[revenue] [region]' },
+            });
+
+            expect(new URL(getIFrameSrc()).searchParams.get(Param.searchTokenString)).toBe(
+                '[revenue] [region]',
+            );
+            expect(embedParams).not.toHaveProperty(Param.searchTokenString);
+        });
+
+        test('sends the token in searchOptions when it is excluded from the URL', async () => {
+            const appInitData = await getAppInitFor(SearchEmbed, {
+                dataSource: 'ds-1',
+                excludeSearchTokenStringFromURL: true,
+                searchOptions: { searchTokenString: '[revenue]' },
+            });
+
+            expect(getIFrameSrc()).not.toContain(Param.searchTokenString);
+            // The app merges searchOptions.searchTokenString into embedParams.
+            expect(appInitData.searchOptions).toEqual({ searchTokenString: '[revenue]' });
+            expect(appInitData.embedParams).not.toHaveProperty(Param.searchTokenString);
+        });
+
+        test('sends a flag the caller set to false', async () => {
+            const { embedParams } = await getAppInitFor(AppEmbed, {
+                showPrimaryNavbar: true,
+                liveboardV2: false,
+                modularHomeExperience: false,
+            });
+
+            expect(embedParams).toEqual(
+                expect.objectContaining({
+                    [Param.PrimaryNavHidden]: false,
+                    [Param.LiveboardV2Enabled]: false,
+                    [Param.ModularHomeExperienceEnabled]: false,
+                }),
+            );
+        });
+
+        test('sends a flag only when the caller sets it', async () => {
+            const { embedParams } = await getAppInitFor(AppEmbed, {});
+
+            expect(embedParams).not.toHaveProperty(Param.HideHamburger);
+            expect(embedParams).not.toHaveProperty(Param.HideNotification);
+            expect(embedParams).not.toHaveProperty(Param.ModularHomeExperienceEnabled);
+        });
+
+        test('does not repeat the params that stay on the URL', async () => {
+            const { embedParams } = await getAppInitFor(LiveboardEmbed, { liveboardId });
+
+            Object.keys(embedParams).forEach((key) => {
+                expect(BOOTSTRAP_URL_PARAMS.has(key)).toBe(false);
+            });
+        });
+
+        test('leaves the APP_INIT payload unchanged when the flag is not set', async () => {
+            await renderEmbed(LiveboardEmbed, { liveboardId, hideLiveboardHeader: true }, false);
+            const appInitData = await requestAppInit();
+
+            expect(appInitData).not.toHaveProperty('embedParams');
+            expect(appInitData).not.toHaveProperty(Param.HideLiveboardHeader);
+        });
+
+        test('sends no embedParams when every param stays on the URL', async () => {
+            const getParams = jest
+                .spyOn(LiveboardEmbed.prototype as any, 'getEmbedParamsObject')
+                .mockReturnValue({
+                    [Param.EmbedApp]: true,
+                    [Param.AuthType]: AuthType.None,
+                });
+            await renderEmbed(LiveboardEmbed, { liveboardId });
+            const appInitData = await requestAppInit();
+            getParams.mockRestore();
+
+            expect(appInitData).not.toHaveProperty('embedParams');
+        });
+
+        test('sends the params when excludeConfigFromURL is set in init', async () => {
+            init({
+                thoughtSpotHost,
+                authType: AuthType.None,
+                additionalFlags: { excludeConfigFromURL: true },
+            });
+            await renderEmbed(LiveboardEmbed, { liveboardId, hideLiveboardHeader: true }, false);
+            const { embedParams } = await requestAppInit();
+
+            expect(getIFrameSrc()).not.toContain(`${Param.HideLiveboardHeader}=`);
+            expect(embedParams).toEqual(
+                expect.objectContaining({ [Param.HideLiveboardHeader]: true }),
+            );
+        });
+
+        test('sends the params for a pre-rendered embed', async () => {
+            (window as any).ResizeObserver =
+                window.ResizeObserver ||
+                jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: jest.fn(),
+                    unobserve: jest.fn(),
+                }));
+            const embed = new LiveboardEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                ...withPostMessage({ liveboardId, hideLiveboardHeader: true }),
+                preRenderId: 'app-init-pre-render',
+            });
+            await embed.preRender();
+            await waitFor(() => !!getIFrameEl());
+            const { embedParams } = await requestAppInit();
+
+            expect(embedParams).toEqual(
+                expect.objectContaining({ [Param.HideLiveboardHeader]: true }),
+            );
+        });
+
+        test('does not add the APP_INIT copy to UpdateEmbedParams', async () => {
+            mockMessageChannel();
+            (window as any).ResizeObserver =
+                window.ResizeObserver ||
+                jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: jest.fn(),
+                    unobserve: jest.fn(),
+                }));
+            const embed = new LiveboardEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                ...withPostMessage({ liveboardId, hideLiveboardHeader: true }),
+                preRenderId: 'app-init-copy-pre-render',
+            });
+            await embed.preRender();
+            await waitFor(() => !!getIFrameEl());
+            signalFrameReady();
+            await executeAfterWait(() => {
+                expect(embed.isEmbedContainerLoaded).toBe(true);
+            });
+            // The show cycle is what sends UpdateEmbedParams.
+            await embed.showPreRender();
+
+            await executeAfterWait(() => {
+                const updateCall = mockProcessTrigger.mock.calls.find(
+                    (call) => call[1] === HostEvent.UpdateEmbedParams,
+                );
+                expect(updateCall[3]).toEqual(
+                    expect.objectContaining({ [Param.HideLiveboardHeader]: true }),
+                );
+                expect(updateCall[3]).not.toHaveProperty('embedParams');
+            });
+        });
+
+        // BOOTSTRAP_URL_PARAMS is the source of truth. Each param goes
+        // through additionalFlags so it is checked on its own.
+        test.each([...BOOTSTRAP_URL_PARAMS])('keeps %s on the URL', async (param) => {
+            await renderEmbed(LiveboardEmbed, {
+                liveboardId,
+                additionalFlags: { [param]: 'bootstrap-value' },
+            });
+
+            expect(new URL(getIFrameSrc()).searchParams.has(param)).toBe(true);
+        });
+    });
+
+    test('strips a non-bootstrap additionalFlag from the URL when the flag is set', async () => {
+        const { src } = await renderAndGetSrc({
+            ...lbConfig,
+            additionalFlags: {
+                internalBlinkFlag: true,
+                someCustomFlag: 'abc',
+                excludeConfigFromURL: true,
+            },
+        });
+
+        expect(src).not.toContain('internalBlinkFlag');
+        expect(src).not.toContain('someCustomFlag');
+    });
+
+    test('keeps an additionalFlag that overrides a bootstrap param on the URL', async () => {
+        const { src } = await renderAndGetSrc({
+            ...lbConfig,
+            additionalFlags: { [Param.OverrideOrgId]: 42, excludeConfigFromURL: true },
+        });
+
+        expect(src).toContain(`${Param.OverrideOrgId}=42`);
+    });
+
+    test('keeps the dark mode params on the URL when the flag is set', async () => {
+        const { src } = await renderAndGetSrc(withPostMessage({ ...lbConfig, isDarkMode: true }));
+
+        expect(src).toContain(`${Param.IsDarkMode}=true`);
+        expect(src).toContain(`${Param.RadiantThemeEnabled}=true`);
+    });
+
+    test('keeps the deep-link route on the URL when the flag is set', async () => {
+        const { src } = await renderAndGetSrc(withPostMessage(lbConfig));
+
+        expect(src).toContain(`/embed/viz/${liveboardId}`);
+    });
+
+    test('sends the config in APP_INIT, not UpdateEmbedParams, on the first load', async () => {
+        await renderAndGetSrc(withPostMessage(lbConfig));
+        const mockPort: any = { postMessage: jest.fn() };
+        postMessageToParent(
+            getIFrameEl().contentWindow,
+            { type: EmbedEvent.APP_INIT, data: {} },
+            mockPort,
+        );
+        await waitFor(() => mockPort.postMessage.mock.calls.length > 0);
+        signalFrameReady();
+
+        expect(mockPort.postMessage.mock.calls[0][0].data.embedParams).toEqual(
+            expect.objectContaining({
+                internalBlinkFlag: true,
+                [Param.HideActions]: expect.arrayContaining([Action.Download]),
+            }),
+        );
+        await executeAfterWait(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter(
+                (call) => call[1] === HostEvent.UpdateEmbedParams,
+            );
+            expect(updateCalls).toHaveLength(0);
+        });
+    });
+
+    test('does not send UpdateEmbedParams when the flag is not set', async () => {
+        await renderAndGetSrc(lbConfig);
+
+        signalFrameReady();
+
+        await executeAfterWait(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter(
+                (call) => call[1] === HostEvent.UpdateEmbedParams,
+            );
+            expect(updateCalls).toHaveLength(0);
+        });
+    });
+
+    test('does not double-send for a pre-rendered embed that is shown', async () => {
+        mockMessageChannel();
+        (window as any).ResizeObserver =
+            window.ResizeObserver ||
+            jest.fn().mockImplementation(() => ({
+                disconnect: jest.fn(),
+                observe: jest.fn(),
+                unobserve: jest.fn(),
+            }));
+
+        const embed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            ...withPostMessage(lbConfig),
+            preRenderId: 'send-config-post-message',
+        });
+        await embed.preRender();
+        await waitFor(() => !!getIFrameEl());
+
+        signalFrameReady();
+        await executeAfterWait(() => {
+            expect(embed.isEmbedContainerLoaded).toBe(true);
+        });
+        // The frame being ready sends nothing; the config went in APP_INIT.
+        expect(
+            mockProcessTrigger.mock.calls.filter(
+                (call) => call[1] === HostEvent.UpdateEmbedParams,
+            ),
+        ).toHaveLength(0);
+
+        mockProcessTrigger.mockClear();
+        await embed.showPreRender();
+
+        await executeAfterWait(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter(
+                (call) => call[1] === HostEvent.UpdateEmbedParams,
+            );
+            expect(updateCalls).toHaveLength(1);
+        });
+    });
+});