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

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

@@ -11,6 +11,7 @@ const test_utils_1 = require("../test/test-utils");
 const config = tslib_1.__importStar(require("../config"));
 const embedConfig = tslib_1.__importStar(require("./embedConfig"));
 const tsEmbedInstance = tslib_1.__importStar(require("./ts-embed"));
+const ts_embed_1 = require("./ts-embed");
 const mixpanelInstance = tslib_1.__importStar(require("../mixpanel-service"));
 const authInstance = tslib_1.__importStar(require("../auth"));
 const baseInstance = tslib_1.__importStar(require("./base"));
@@ -27,9 +28,6 @@ const apiIntercept = tslib_1.__importStar(require("../api-intercept"));
 const processData = tslib_1.__importStar(require("../utils/processData"));
 jest.mock('../utils/processTrigger');
 const mockProcessTrigger = processTrigger_1.processTrigger;
-const flushAnimationFrame = () => new Promise((resolve) => {
-    requestAnimationFrame(() => resolve());
-});
 const mockHandleInterceptEvent = jest.spyOn(apiIntercept, 'handleInterceptEvent');
 const defaultViewConfig = {
     frameParams: {
@@ -1098,6 +1096,26 @@ describe('Unit test case for ts embed', () => {
                 elHeight: 0,
             }));
         });
+        test('should send visual-sdk-init-actions with configured actions, [] when unused', async () => {
+            await new index_1.SearchEmbed((0, test_utils_1.getRootEl)(), {
+                hiddenActions: [types_1.Action.Download],
+                disabledActions: [types_1.Action.Edit],
+            }).render();
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_INIT_ACTIONS, expect.objectContaining({
+                hiddenActions: [types_1.Action.Download],
+                visibleActions: [],
+                disabledActions: [types_1.Action.Edit],
+            }));
+            mockMixPanelEvent.mockClear();
+            await new index_1.SearchEmbed((0, test_utils_1.getRootEl)(), {
+                visibleActions: [types_1.Action.Save],
+            }).render();
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_INIT_ACTIONS, expect.objectContaining({
+                hiddenActions: [],
+                visibleActions: [types_1.Action.Save],
+                disabledActions: [],
+            }));
+        });
         test('Should remove prefetch iframe', async () => {
             await setup(true);
             const prefetchIframe = document.querySelectorAll('.prefetchIframe');
@@ -2115,6 +2133,71 @@ describe('Unit test case for ts embed', () => {
             });
         });
     });
+    describe('isDarkMode', () => {
+        const renderAppEmbed = async (viewConfig = {}) => {
+            const appEmbed = new index_1.AppEmbed((0, test_utils_1.getRootEl)(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                ...viewConfig,
+            });
+            appEmbed.render();
+            await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
+            return (0, test_utils_1.getIFrameSrc)();
+        };
+        it('sends the appearance the host asked for in init, with the radiant theme', async () => {
+            (0, index_1.init)({
+                thoughtSpotHost: 'tshost',
+                authType: index_1.AuthType.None,
+                isDarkMode: true,
+            });
+            (0, test_utils_1.expectUrlToHaveParamsWithValues)(await renderAppEmbed(), {
+                isDarkMode: true,
+                radiantThemeEnabled: true,
+            });
+        });
+        it('sends an explicit false', async () => {
+            (0, index_1.init)({
+                thoughtSpotHost: 'tshost',
+                authType: index_1.AuthType.None,
+                isDarkMode: false,
+            });
+            const src = await renderAppEmbed();
+            (0, test_utils_1.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 () => {
+            (0, index_1.init)({
+                thoughtSpotHost: 'tshost',
+                authType: index_1.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 () => {
+            (0, index_1.init)({
+                thoughtSpotHost: 'tshost',
+                authType: index_1.AuthType.None,
+                isDarkMode: true,
+            });
+            const src = await renderAppEmbed({ isDarkMode: false });
+            (0, test_utils_1.expectUrlToHaveParamsWithValues)(src, { isDarkMode: false });
+            expect(src).not.toContain('radiantThemeEnabled=');
+        });
+        it('lets additionalFlags override the radiant theme it turns on', async () => {
+            (0, index_1.init)({
+                thoughtSpotHost: 'tshost',
+                authType: index_1.AuthType.None,
+                isDarkMode: true,
+            });
+            (0, test_utils_1.expectUrlToHaveParamsWithValues)(await renderAppEmbed({ additionalFlags: { radiantThemeEnabled: false } }), { isDarkMode: true, radiantThemeEnabled: false });
+        });
+    });
     describe('validate preRender flow', () => {
         beforeAll(() => {
             (0, index_1.init)({
@@ -2175,12 +2258,10 @@ 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`);
             expect(preRenderWrapper.style.opacity).toBe('');
-            expect(preRenderWrapper.style.pointerEvents).toBe('auto');
+            expect(preRenderWrapper.style.pointerEvents).toBe('');
             expect(preRenderWrapper.style.zIndex).toBe('');
             libEmbed.hidePreRender();
             expect(preRenderWrapper.style.opacity).toBe('0');
@@ -2209,7 +2290,7 @@ describe('Unit test case for ts embed', () => {
             await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
             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('');
         });
         it('hidePreRender should not preRender if not available', async () => {
@@ -2349,170 +2430,6 @@ describe('Unit test case for ts embed', () => {
             libEmbed.destroy();
             logger_1.logger.debug.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 = () => {
-                (0, test_utils_1.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,
-                });
-                const placeholderTopAtRest = 400;
-                const readPlaceholderTop = () => placeholderTopAtRest - scroller.scrollTop;
-                return { scroller, readPlaceholderTop };
-            };
-            const stubPlaceholderRect = (embed, readTop) => {
-                const placeholder = embed.getPreRenderPlaceHolderElement();
-                placeholder.getBoundingClientRect = () => {
-                    const top = readTop();
-                    return {
-                        x: 0, y: top, width: 800, height: 300,
-                        top, left: 0, bottom: top + 300, right: 800,
-                    };
-                };
-                return placeholder;
-            };
-            it('should stop tracking once the frame is hidden', async () => {
-                const { scroller, readPlaceholderTop } = mountInNestedScroller();
-                const libEmbed = new index_1.LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'scroll-stops-on-hide',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
-                await libEmbed.showPreRender();
-                stubPlaceholderRect(libEmbed, readPlaceholderTop);
-                libEmbed.hidePreRender();
-                const syncSpy = jest.spyOn(libEmbed, 'syncPreRenderStyle');
-                scroller.scrollTop = 250;
-                scroller.dispatchEvent(new Event('scroll'));
-                await flushAnimationFrame();
-                expect(syncSpy).not.toHaveBeenCalled();
-                syncSpy.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 index_1.LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'auto-scroll-container',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.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.preRenderContainerEl).toBe(scroller);
-                libEmbed.destroy();
-                scroller.remove();
-            });
-            it('should still use document.body when nothing scrolls', async () => {
-                (0, test_utils_1.createRootEleForEmbed)();
-                const libEmbed = new index_1.LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'no-scroller-body',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.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 () => {
-                (0, test_utils_1.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 index_1.LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'pointer-events-restored',
-                    liveboardId: 'myLiveboardId',
-                    preRenderContainer: '#parking-root',
-                });
-                libEmbed.preRender();
-                await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.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 () => {
-                (0, test_utils_1.createRootEleForEmbed)();
-                const libEmbed = new index_1.LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'hidden-parked',
-                    liveboardId: 'myLiveboardId',
-                });
-                libEmbed.preRender();
-                await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.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 () => {
-                (0, test_utils_1.createRootEleForEmbed)();
-                const libEmbed = new index_1.LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'unmeasured-height',
-                    liveboardId: 'myLiveboardId',
-                    fullHeight: true,
-                    frameParams: { height: 420 },
-                });
-                libEmbed.preRender();
-                await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.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.getPreRenderPlaceHolderElement();
-                expect(placeholder.style.height).toBe('420px');
-                libEmbed.destroy();
-            });
-            it('should seed the placeholder with a height fullHeight has measured', async () => {
-                (0, test_utils_1.createRootEleForEmbed)();
-                const libEmbed = new index_1.LiveboardEmbed('#tsEmbedDiv', {
-                    preRenderId: 'measured-height',
-                    liveboardId: 'myLiveboardId',
-                    fullHeight: true,
-                    frameParams: { height: 420 },
-                });
-                libEmbed.preRender();
-                await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
-                libEmbed.setIFrameHeight(1180);
-                await libEmbed.showPreRender();
-                const placeholder = libEmbed.getPreRenderPlaceHolderElement();
-                expect(placeholder.style.height).toBe('1180px');
-                libEmbed.destroy();
-            });
-        });
         describe('preRenderContainer', () => {
             it('should append preRenderWrapper to document.body when preRenderContainer is not set', async () => {
                 (0, test_utils_1.createRootEleForEmbed)();
@@ -2731,14 +2648,19 @@ describe('Unit test case for ts embed', () => {
                 expect(oldContainer.contains(wrapper)).toBe(true);
                 // 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();
             });
@@ -5500,4 +5422,454 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
     });
 });
+describe('excludeConfigFromURL', () => {
+    const lbConfig = {
+        liveboardId,
+        hiddenActions: [types_1.Action.Download],
+        additionalFlags: { internalBlinkFlag: true },
+        liveboardV2: true,
+    };
+    const withPostMessage = (viewConfig) => ({
+        ...viewConfig,
+        additionalFlags: { ...viewConfig.additionalFlags, excludeConfigFromURL: true },
+    });
+    const renderAndGetSrc = async (viewConfig) => {
+        const embed = new index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), { ...defaultViewConfig, ...viewConfig });
+        await embed.render();
+        await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
+        return { embed, src: (0, test_utils_1.getIFrameSrc)() };
+    };
+    const signalFrameReady = () => {
+        (0, test_utils_1.postMessageToParent)((0, test_utils_1.getIFrameEl)().contentWindow, {
+            type: index_1.EmbedEvent.EmbedListenerReady,
+        });
+    };
+    beforeEach(() => {
+        document.body.innerHTML = (0, test_utils_1.getDocumentBody)();
+        mockProcessTrigger.mockReset();
+        mockProcessTrigger.mockResolvedValue({});
+        (0, index_1.init)({
+            thoughtSpotHost,
+            authType: index_1.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=${index_1.AuthType.None}`);
+        expect(src).toContain(`sdkVersion=${package_json_1.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', () => {
+            [types_1.Param.EmbedApp, types_1.Param.HostAppUrl, types_1.Param.Version, types_1.Param.AuthType].forEach((param) => {
+                expect(ts_embed_1.BOOTSTRAP_URL_PARAMS.has(param)).toBe(true);
+            });
+        });
+        test('leaves the layout flags to the APP_INIT payload', () => {
+            [
+                types_1.Param.LiveboardV2Enabled,
+                types_1.Param.PrimaryNavHidden,
+                types_1.Param.HideSearchBar,
+                types_1.Param.SpotterExperienceVersion,
+            ].forEach((param) => {
+                expect(ts_embed_1.BOOTSTRAP_URL_PARAMS.has(param)).toBe(false);
+            });
+        });
+    });
+    describe('params held back from the URL go in the APP_INIT payload', () => {
+        const renderEmbed = async (EmbedClass, viewConfig, excludeConfig = true) => {
+            const embed = new EmbedClass((0, test_utils_1.getRootEl)(), {
+                ...defaultViewConfig,
+                ...viewConfig,
+                additionalFlags: {
+                    ...viewConfig.additionalFlags,
+                    ...(excludeConfig && { excludeConfigFromURL: true }),
+                },
+            });
+            await embed.render();
+            await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
+            return embed;
+        };
+        const requestAppInit = async () => {
+            const mockPort = { postMessage: jest.fn() };
+            (0, test_utils_1.postMessageToParent)((0, test_utils_1.getIFrameEl)().contentWindow, { type: index_1.EmbedEvent.APP_INIT, data: {} }, mockPort);
+            await (0, test_utils_1.waitFor)(() => mockPort.postMessage.mock.calls.length > 0);
+            return mockPort.postMessage.mock.calls[0][0].data;
+        };
+        const getAppInitFor = async (EmbedClass, viewConfig) => {
+            await renderEmbed(EmbedClass, viewConfig);
+            return requestAppInit();
+        };
+        test('sends the app navigation and page version flags', async () => {
+            const { embedParams } = await getAppInitFor(index_1.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({
+                [types_1.Param.PrimaryNavHidden]: true,
+                [types_1.Param.HideHamburger]: true,
+                [types_1.Param.HideNotification]: true,
+                [types_1.Param.HideObjectSearch]: true,
+                [types_1.Param.HideOrgSwitcher]: true,
+                [types_1.Param.HideApplicationSwitcher]: true,
+                [types_1.Param.HideProfleAndHelp]: true,
+                [types_1.Param.HideHomepageLeftNav]: true,
+                [types_1.Param.HideTagFilterChips]: true,
+                [types_1.Param.ModularHomeExperienceEnabled]: true,
+                [types_1.Param.LiveboardV2Enabled]: true,
+                [types_1.Param.NavigationVersion]: expect.any(String),
+                [types_1.Param.HomepageVersion]: expect.any(String),
+            }));
+        });
+        test('sends the Liveboard layout flags', async () => {
+            const { embedParams } = await getAppInitFor(index_1.LiveboardEmbed, {
+                liveboardId,
+                visibleVizs: ['viz-1'],
+                hideLiveboardHeader: true,
+                showLiveboardTitle: true,
+                showLiveboardDescription: true,
+                hideTabPanel: true,
+                enable2ColumnLayout: true,
+                isLiveboardHeaderSticky: true,
+                showLiveboardVerifiedBadge: true,
+            });
+            expect(embedParams).toEqual(expect.objectContaining({
+                [types_1.Param.visibleVizs]: ['viz-1'],
+                [types_1.Param.HideLiveboardHeader]: true,
+                [types_1.Param.ShowLiveboardTitle]: true,
+                [types_1.Param.ShowLiveboardDescription]: true,
+                [types_1.Param.HideTabPanel]: true,
+                [types_1.Param.Enable2ColumnLayout]: true,
+                [types_1.Param.LiveboardHeaderSticky]: true,
+                [types_1.Param.ShowLiveboardVerifiedBadge]: true,
+            }));
+        });
+        test('sends the search layout flags and the initial query', async () => {
+            const { embedParams } = await getAppInitFor(index_1.SearchEmbed, {
+                dataSource: 'ds-1',
+                searchOptions: {
+                    searchTokenString: '[revenue]',
+                    executeSearch: true,
+                },
+                hideResults: true,
+                hideSearchBar: true,
+                collapseSearchBarInitially: true,
+                enableSearchAssist: true,
+            });
+            expect(embedParams).toEqual(expect.objectContaining({
+                [types_1.Param.HideResult]: true,
+                [types_1.Param.HideSearchBar]: true,
+                [types_1.Param.CollapseSearchBarInitially]: true,
+                [types_1.Param.EnableSearchAssist]: true,
+                [types_1.Param.executeSearch]: true,
+                [types_1.Param.DataSourceMode]: expect.anything(),
+            }));
+            expect(embedParams).not.toHaveProperty(types_1.Param.searchTokenString);
+        });
+        test('sends the Spotter empty-screen flags', async () => {
+            const { embedParams } = await getAppInitFor(index_1.SpotterEmbed, {
+                worksheetId: 'worksheet-1',
+                hideSampleQuestions: true,
+                hideSourceSelection: true,
+                disableSourceSelection: true,
+                showSpotterLimitations: true,
+                showSpotterRadiance: true,
+                updatedSpotterChatPrompt: true,
+                spotterChatConfig: { enableStarterPrompts: true },
+            });
+            expect(embedParams).toEqual(expect.objectContaining({
+                [types_1.Param.HideSampleQuestions]: true,
+                [types_1.Param.HideSourceSelection]: true,
+                [types_1.Param.DisableSourceSelection]: true,
+                [types_1.Param.ShowSpotterLimitations]: true,
+                [types_1.Param.ShowSpotterRadiance]: true,
+                [types_1.Param.UpdatedSpotterChatPrompt]: true,
+                [types_1.Param.IsStarterPromptsEnabled]: true,
+            }));
+        });
+        test('sends the action and tab lists and the additionalFlags', async () => {
+            await renderEmbed(index_1.LiveboardEmbed, {
+                liveboardId,
+                visibleActions: [types_1.Action.Download],
+                visibleTabs: ['tab-1'],
+                additionalFlags: { internalBlinkFlag: true },
+            });
+            const src = (0, test_utils_1.getIFrameSrc)();
+            const { embedParams } = await requestAppInit();
+            expect(src).not.toContain(`${types_1.Param.VisibleActions}=`);
+            expect(src).not.toContain(`${types_1.Param.VisibleTabs}=`);
+            expect(embedParams).toEqual(expect.objectContaining({
+                [types_1.Param.VisibleActions]: [types_1.Action.Download],
+                [types_1.Param.VisibleTabs]: ['tab-1'],
+                internalBlinkFlag: true,
+            }));
+        });
+        test('sends the feature flags only in embedParams', async () => {
+            const appInitData = await getAppInitFor(index_1.AppEmbed, {
+                showPrimaryNavbar: false,
+                liveboardV2: true,
+                dataPanelV2: true,
+            });
+            const featureFlags = {
+                [types_1.Param.PrimaryNavHidden]: true,
+                [types_1.Param.LiveboardV2Enabled]: true,
+                [types_1.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(index_1.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(index_1.SpotterEmbed, {
+                worksheetId: 'worksheet-1',
+                hideSampleQuestions: true,
+                spotterSidebarConfig: { enablePastConversationsSidebar: true },
+            });
+            expect(embedParams).toEqual(expect.objectContaining({
+                [types_1.Param.HideSampleQuestions]: true,
+                spotterSidebarConfig: expect.objectContaining({
+                    enablePastConversationsSidebar: true,
+                }),
+            }));
+        });
+        test('keeps the search token on the URL', async () => {
+            const { embedParams } = await getAppInitFor(index_1.SearchEmbed, {
+                dataSource: 'ds-1',
+                searchOptions: { searchTokenString: '[revenue] [region]' },
+            });
+            expect(new URL((0, test_utils_1.getIFrameSrc)()).searchParams.get(types_1.Param.searchTokenString)).toBe('[revenue] [region]');
+            expect(embedParams).not.toHaveProperty(types_1.Param.searchTokenString);
+        });
+        test('sends the token in searchOptions when it is excluded from the URL', async () => {
+            const appInitData = await getAppInitFor(index_1.SearchEmbed, {
+                dataSource: 'ds-1',
+                excludeSearchTokenStringFromURL: true,
+                searchOptions: { searchTokenString: '[revenue]' },
+            });
+            expect((0, test_utils_1.getIFrameSrc)()).not.toContain(types_1.Param.searchTokenString);
+            // The app merges searchOptions.searchTokenString into embedParams.
+            expect(appInitData.searchOptions).toEqual({ searchTokenString: '[revenue]' });
+            expect(appInitData.embedParams).not.toHaveProperty(types_1.Param.searchTokenString);
+        });
+        test('sends a flag the caller set to false', async () => {
+            const { embedParams } = await getAppInitFor(index_1.AppEmbed, {
+                showPrimaryNavbar: true,
+                liveboardV2: false,
+                modularHomeExperience: false,
+            });
+            expect(embedParams).toEqual(expect.objectContaining({
+                [types_1.Param.PrimaryNavHidden]: false,
+                [types_1.Param.LiveboardV2Enabled]: false,
+                [types_1.Param.ModularHomeExperienceEnabled]: false,
+            }));
+        });
+        test('sends a flag only when the caller sets it', async () => {
+            const { embedParams } = await getAppInitFor(index_1.AppEmbed, {});
+            expect(embedParams).not.toHaveProperty(types_1.Param.HideHamburger);
+            expect(embedParams).not.toHaveProperty(types_1.Param.HideNotification);
+            expect(embedParams).not.toHaveProperty(types_1.Param.ModularHomeExperienceEnabled);
+        });
+        test('does not repeat the params that stay on the URL', async () => {
+            const { embedParams } = await getAppInitFor(index_1.LiveboardEmbed, { liveboardId });
+            Object.keys(embedParams).forEach((key) => {
+                expect(ts_embed_1.BOOTSTRAP_URL_PARAMS.has(key)).toBe(false);
+            });
+        });
+        test('leaves the APP_INIT payload unchanged when the flag is not set', async () => {
+            await renderEmbed(index_1.LiveboardEmbed, { liveboardId, hideLiveboardHeader: true }, false);
+            const appInitData = await requestAppInit();
+            expect(appInitData).not.toHaveProperty('embedParams');
+            expect(appInitData).not.toHaveProperty(types_1.Param.HideLiveboardHeader);
+        });
+        test('sends no embedParams when every param stays on the URL', async () => {
+            const getParams = jest
+                .spyOn(index_1.LiveboardEmbed.prototype, 'getEmbedParamsObject')
+                .mockReturnValue({
+                [types_1.Param.EmbedApp]: true,
+                [types_1.Param.AuthType]: index_1.AuthType.None,
+            });
+            await renderEmbed(index_1.LiveboardEmbed, { liveboardId });
+            const appInitData = await requestAppInit();
+            getParams.mockRestore();
+            expect(appInitData).not.toHaveProperty('embedParams');
+        });
+        test('sends the params when excludeConfigFromURL is set in init', async () => {
+            (0, index_1.init)({
+                thoughtSpotHost,
+                authType: index_1.AuthType.None,
+                additionalFlags: { excludeConfigFromURL: true },
+            });
+            await renderEmbed(index_1.LiveboardEmbed, { liveboardId, hideLiveboardHeader: true }, false);
+            const { embedParams } = await requestAppInit();
+            expect((0, test_utils_1.getIFrameSrc)()).not.toContain(`${types_1.Param.HideLiveboardHeader}=`);
+            expect(embedParams).toEqual(expect.objectContaining({ [types_1.Param.HideLiveboardHeader]: true }));
+        });
+        test('sends the params for a pre-rendered embed', async () => {
+            window.ResizeObserver =
+                window.ResizeObserver ||
+                    jest.fn().mockImplementation(() => ({
+                        disconnect: jest.fn(),
+                        observe: jest.fn(),
+                        unobserve: jest.fn(),
+                    }));
+            const embed = new index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), {
+                ...defaultViewConfig,
+                ...withPostMessage({ liveboardId, hideLiveboardHeader: true }),
+                preRenderId: 'app-init-pre-render',
+            });
+            await embed.preRender();
+            await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
+            const { embedParams } = await requestAppInit();
+            expect(embedParams).toEqual(expect.objectContaining({ [types_1.Param.HideLiveboardHeader]: true }));
+        });
+        test('does not add the APP_INIT copy to UpdateEmbedParams', async () => {
+            (0, test_utils_1.mockMessageChannel)();
+            window.ResizeObserver =
+                window.ResizeObserver ||
+                    jest.fn().mockImplementation(() => ({
+                        disconnect: jest.fn(),
+                        observe: jest.fn(),
+                        unobserve: jest.fn(),
+                    }));
+            const embed = new index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), {
+                ...defaultViewConfig,
+                ...withPostMessage({ liveboardId, hideLiveboardHeader: true }),
+                preRenderId: 'app-init-copy-pre-render',
+            });
+            await embed.preRender();
+            await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
+            signalFrameReady();
+            await (0, test_utils_1.executeAfterWait)(() => {
+                expect(embed.isEmbedContainerLoaded).toBe(true);
+            });
+            // The show cycle is what sends UpdateEmbedParams.
+            await embed.showPreRender();
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const updateCall = mockProcessTrigger.mock.calls.find((call) => call[1] === types_1.HostEvent.UpdateEmbedParams);
+                expect(updateCall[3]).toEqual(expect.objectContaining({ [types_1.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([...ts_embed_1.BOOTSTRAP_URL_PARAMS])('keeps %s on the URL', async (param) => {
+            await renderEmbed(index_1.LiveboardEmbed, {
+                liveboardId,
+                additionalFlags: { [param]: 'bootstrap-value' },
+            });
+            expect(new URL((0, test_utils_1.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: { [types_1.Param.OverrideOrgId]: 42, excludeConfigFromURL: true },
+        });
+        expect(src).toContain(`${types_1.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(`${types_1.Param.IsDarkMode}=true`);
+        expect(src).toContain(`${types_1.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 = { postMessage: jest.fn() };
+        (0, test_utils_1.postMessageToParent)((0, test_utils_1.getIFrameEl)().contentWindow, { type: index_1.EmbedEvent.APP_INIT, data: {} }, mockPort);
+        await (0, test_utils_1.waitFor)(() => mockPort.postMessage.mock.calls.length > 0);
+        signalFrameReady();
+        expect(mockPort.postMessage.mock.calls[0][0].data.embedParams).toEqual(expect.objectContaining({
+            internalBlinkFlag: true,
+            [types_1.Param.HideActions]: expect.arrayContaining([types_1.Action.Download]),
+        }));
+        await (0, test_utils_1.executeAfterWait)(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter((call) => call[1] === types_1.HostEvent.UpdateEmbedParams);
+            expect(updateCalls).toHaveLength(0);
+        });
+    });
+    test('does not send UpdateEmbedParams when the flag is not set', async () => {
+        await renderAndGetSrc(lbConfig);
+        signalFrameReady();
+        await (0, test_utils_1.executeAfterWait)(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter((call) => call[1] === types_1.HostEvent.UpdateEmbedParams);
+            expect(updateCalls).toHaveLength(0);
+        });
+    });
+    test('does not double-send for a pre-rendered embed that is shown', async () => {
+        (0, test_utils_1.mockMessageChannel)();
+        window.ResizeObserver =
+            window.ResizeObserver ||
+                jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: jest.fn(),
+                    unobserve: jest.fn(),
+                }));
+        const embed = new index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), {
+            ...defaultViewConfig,
+            ...withPostMessage(lbConfig),
+            preRenderId: 'send-config-post-message',
+        });
+        await embed.preRender();
+        await (0, test_utils_1.waitFor)(() => !!(0, test_utils_1.getIFrameEl)());
+        signalFrameReady();
+        await (0, test_utils_1.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] === types_1.HostEvent.UpdateEmbedParams)).toHaveLength(0);
+        mockProcessTrigger.mockClear();
+        await embed.showPreRender();
+        await (0, test_utils_1.executeAfterWait)(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter((call) => call[1] === types_1.HostEvent.UpdateEmbedParams);
+            expect(updateCalls).toHaveLength(1);
+        });
+    });
+});
 //# sourceMappingURL=ts-embed.spec.js.map