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

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"));
@@ -1095,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');
@@ -2112,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)({
@@ -2468,7 +2554,12 @@ describe('Unit test case for ts embed', () => {
                 const wrapper = document.getElementById(libEmbed.getPreRenderIds().wrapper);
                 expect(wrapper.style.transform).toBe('');
                 libEmbed.hidePreRender();
+                // Detached from every scroll container (fixed, resolves to the
+                // viewport), parked for the captured-fixed case, size
+                // preserved.
+                expect(wrapper.style.position).toBe('fixed');
                 expect(wrapper.style.transform).toBe('translateY(-100%)');
+                expect(wrapper.style.height).not.toBe('');
                 await libEmbed.showPreRender();
                 expect(wrapper.style.transform).toBe('');
                 libEmbed.destroy();
@@ -5495,4 +5586,523 @@ 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);
+        });
+    });
+});
+describe('visual-sdk-embed-create does not upload runtime filter or parameter data', () => {
+    // Spied per test: an earlier suite calls jest.restoreAllMocks(), which
+    // would unwire a spy created at collection time.
+    let mockMixPanelEvent;
+    const runtimeFilters = [
+        {
+            columnName: 'Patient SSN',
+            operator: types_1.RuntimeFilterOp.EQ,
+            values: ['123-45-6789'],
+        },
+    ];
+    const runtimeParameters = [
+        {
+            name: 'Sales Region',
+            value: 'EMEA',
+        },
+    ];
+    beforeAll(() => {
+        (0, index_1.init)({
+            thoughtSpotHost: 'tshost',
+            authType: index_1.AuthType.None,
+        });
+    });
+    beforeEach(() => {
+        document.body.innerHTML = (0, test_utils_1.getDocumentBody)();
+        mockMixPanelEvent = jest.spyOn(mixpanelInstance, 'uploadMixpanelEvent');
+    });
+    afterEach(() => {
+        mockMixPanelEvent.mockRestore();
+    });
+    const getEmbedCreateProps = () => {
+        const call = mockMixPanelEvent.mock.calls.find(([eventId]) => eventId === mixpanel_service_1.MIXPANEL_EVENT.VISUAL_SDK_EMBED_CREATE);
+        expect(call).toBeDefined();
+        return call[1];
+    };
+    test('uploads the summary instead of the filters and parameters', () => {
+        new index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), {
+            liveboardId: 'lb-guid',
+            runtimeFilters,
+            runtimeParameters,
+        });
+        expect(getEmbedCreateProps()).toEqual(expect.objectContaining({
+            liveboardId: 'lb-guid',
+            runtimeFilters: { count: 1, operators: ['EQ'] },
+            runtimeParameters: { count: 1, applicabilityLevels: [] },
+        }));
+    });
+    test('no column name, parameter name or operand reaches mixpanel', () => {
+        new index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), {
+            liveboardId: 'lb-guid',
+            runtimeFilters,
+            runtimeParameters,
+        });
+        const uploaded = JSON.stringify(getEmbedCreateProps());
+        ['Patient SSN', '123-45-6789', 'Sales Region', 'EMEA'].forEach((customerValue) => {
+            expect(uploaded).not.toContain(customerValue);
+        });
+    });
+    test('an embed with no runtime filters is unchanged', () => {
+        new index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), {
+            liveboardId: 'lb-guid',
+        });
+        const props = getEmbedCreateProps();
+        expect(props).toEqual({
+            liveboardId: 'lb-guid',
+            embedComponentType: 'LiveboardEmbed',
+        });
+    });
+});
 //# sourceMappingURL=ts-embed.spec.js.map