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

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

@@ -12335,7 +12335,7 @@ class TsEmbed {
 	private defaultHiddenActions;
 	private resizeObserver;
 	private preRenderContainerEl;
-	private containerScrollListener;
+	/** Last height the embedded app reported, once fullHeight has measured one. */
 	protected hostEventClient: HostEventClient;
 	protected isReadyForRenderPromise: Promise<void>;
 	protected shouldWaitForRenderPromise: boolean;
@@ -12550,7 +12550,6 @@ class TsEmbed {
 	protected getV1EmbedBasePath(queryString: string): string;
 	protected getEmbedParams(): string;
 	protected getEmbedParamsObject(): Record<any, any>;
-	protected getUrlQueryParamsObject(): Record<any, any>;
 	protected getRootIframeSrc(): string;
 	protected createIframeEl(frameSrc: string): HTMLIFrameElement;
 	/**
@@ -12592,10 +12591,26 @@ class TsEmbed {
 	 */
 	private createPreRenderPlaceholder;
 	/**
-	 * Resolves the configured preRenderContainer to a live element, falling
-	 * back to `document.body`. A string selector is re-queried on every call so
-	 * a remounted container (E.g.: React replacing the node) resolves to the
-	 * fresh element; an element passed directly cannot be re-resolved.
+	 * Resolves the configured preRenderContainer to a live element. A string
+	 * selector is re-queried on every call so a remounted container (E.g.: React
+	 * replacing the node) resolves to the fresh element; an element passed
+	 * directly cannot be re-resolved.
+	 *
+	 * With nothing configured the frame goes into the host element's nearest
+	 * scrolling ancestor, falling back to `document.body`.
+	 *
+	 * The wrapper is absolutely positioned, so it follows the page for free —
+	 * but only while it sits inside whatever scrolls. `document.body` is right
+	 * only when the document itself is the scroller; an app that scrolls an
+	 * inner element instead left the frame pinned to the viewport while the page
+	 * moved under it (SCAL-338563). Being inside the scroller also lets wheel
+	 * events chain out of the frame into it, which they cannot do from
+	 * `document.body`.
+	 *
+	 * A scrolling ancestor is layout chrome rather than route content, so it
+	 * outlives the embed in practice; and if it does go, the host element goes
+	 * with it and this instance is remounting anyway.
+	 * `reconcilePreRenderContainer` re-runs this on a detached container.
 	 */
 	private resolvePreRenderContainerTarget;
 	private inheritPreRenderContainer;
@@ -12612,8 +12627,9 @@ class TsEmbed {
 	 * Re-attaches the wrapper to a live container when the previously resolved
 	 * one has been detached or no longer holds the wrapper — e.g. the host app
 	 * remounted a custom preRenderContainer, which would otherwise leave a stale
-	 * reference and collapse the wrapper. Only string selectors can be
-	 * re-resolved; a container passed as an element is left untouched.
+	 * reference and collapse the wrapper. Selectors and the auto-resolved
+	 * scrolling ancestor are both re-resolved; a container passed as an element
+	 * is left untouched, as there is nothing to re-query.
 	 */
 	private reconcilePreRenderContainer;
 	protected insertIntoDOMForPreRender(child: string | Node): void;
@@ -12829,9 +12845,17 @@ class TsEmbed {
 	 */
 	private restorePreRenderContainerPosition;
 	/**
-	 * Detaches and clears the container scroll listener, if one is attached.
+	 * Re-sizes the wrapper when its placeholder changes size.
+	 *
+	 * Position deliberately has no equivalent. An absolutely positioned wrapper
+	 * follows its containing block for free, so a correctly placed frame is the
+	 * browser's job and costs nothing; repositioning it on scroll would mean a
+	 * layout read and a style write per frame to compensate for placing it in
+	 * the wrong box. Size is the one thing the browser will not do for us: the
+	 * placeholder grows when the embedded app reports a new height, and the
+	 * wrapper has to be told.
 	 */
-	private removeContainerScrollListener;
+	private observePreRenderSize;
 	/**
 	 * Destroys the ThoughtSpot embed, and remove any nodes from the DOM.
 	 * @version SDK: 1.19.1 | ThoughtSpot: *
@@ -12847,8 +12871,6 @@ class TsEmbed {
 	 */
 	prerenderGeneric(): Promise<any>;
 	protected preRenderParamsApplied: Promise<void>;
-	protected isConfigExcludedFromUrl(): boolean;
-	protected triggerUpdateEmbedParams(): Promise<void>;
 	protected beforePrerenderVisible(): void;
 	/**
 	 * Displays the pre-rendered component inside the host element.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thoughtspot/visual-embed-sdk",
-    "version": "1.52.2-beta",
+    "version": "1.52.2-beta.0",
     "description": "ThoughtSpot Embed SDK",
     "module": "lib/src/index.js",
     "main": "dist/tsembed.js",
@@ -65,7 +65,7 @@
         "test": "npm run test-sdk",
         "posttest": "cat ./coverage/sdk/lcov.info | npx coveralls-next || echo 'Warning: Coveralls upload failed but not breaking the build.'",
         "is-publish-allowed": "node scripts/is-publish-allowed.js",
-        "prepublishOnly": "npm run is-publish-allowed && npm run tsc && npm run bundle-dts-file && npm run bundle-dts && npm run bundle-dts-react && npm run bundle-dts-react-full && npm run build",
+        "prepublishOnly": "npm run is-publish-allowed && npm run test && npm run tsc && npm run bundle-dts-file && npm run bundle-dts && npm run bundle-dts-react && npm run bundle-dts-react-full && npm run build",
         "check-size": "npm run build && size-limit",
         "publish-dev": "npm publish --tag dev",
         "publish-prod": "npm publish --tag latest",

package/src/embed/app.ts

@@ -991,7 +991,7 @@ export class AppEmbed extends V1Embed {
      * embedded Liveboard or visualization.
      */
     protected getEmbedParams() {
-        const params = this.getUrlQueryParamsObject();
+        const params = this.getEmbedParamsObject();
         return getQueryParamString(params, true);
     }
 

package/src/embed/auto-frame-renderer.ts

@@ -108,7 +108,7 @@ class AutoFrameRenderer extends TsEmbed {
      * @returns The constructed URL to use for the ThoughtSpot embed iframe.
      */
     private getMCPIframeSrc(sourceSrc: string) {
-        const queryParams = this.getUrlQueryParamsObject();
+        const queryParams = this.getEmbedParamsObject();
         const sourceURL = new URL(sourceSrc);
         const existingQueryParams = sourceURL.searchParams;
         const existingQueryParamsObject = Object.fromEntries(existingQueryParams);

package/src/embed/bodyless-conversation.ts

@@ -56,7 +56,7 @@ export class ConversationMessage extends TsEmbed {
             messageId,
         } = this.viewConfig;
         const path = 'conv-assist-answer';
-        const queryParams = this.getUrlQueryParamsObject();
+        const queryParams = this.getEmbedParamsObject();
 
         let query = '';
         const queryParamsString = getQueryParamString(queryParams, true);

package/src/embed/conversation.ts

@@ -931,7 +931,7 @@ export class SpotterEmbed extends TsEmbed {
         const path = sharedConversationId
             ? `insights/conv-assist/s/${encodeURIComponent(sharedConversationId)}`
             : 'insights/conv-assist';
-        const queryParams = this.getUrlQueryParamsObject();
+        const queryParams = this.getEmbedParamsObject();
 
         let query = '';
         const queryParamsString = getQueryParamString(queryParams, true);

package/src/embed/liveboard.ts

@@ -599,7 +599,7 @@ export class LiveboardEmbed extends V1Embed {
      * embedded Liveboard or visualization.
      */
     protected getEmbedParams() {
-        const params = this.getUrlQueryParamsObject();
+        const params = this.getEmbedParamsObject();
         const queryParams = getQueryParamString(params, true);
         return queryParams;
     }

package/src/embed/search-bar.tsx

@@ -163,7 +163,7 @@ export class SearchBarEmbed extends TsEmbed {
      * @param dataSources A list of data source GUIDs
      */
     private getIFrameSrc() {
-        const queryParams = this.getUrlQueryParamsObject();
+        const queryParams = this.getEmbedParamsObject();
         const path = 'search-bar-embed';
        
         let query = '';

package/src/embed/search.spec.ts

@@ -854,29 +854,6 @@ test('should pass forceTable parameter when forceTable is true', async () => {
 });
 
 describe('SearchBarEmbed tests', () => {
-    test('should keep view config off the URL when excludeConfigFromURL is set', async () => {
-        const searchBarEmbed = new SearchBarEmbed(getRootEl() as any, {
-            ...defaultViewConfig,
-            dataSources: ['source-1', 'source-2'],
-            additionalFlags: { excludeConfigFromURL: true },
-        } as any);
-        searchBarEmbed.render();
-        await executeAfterWait(() => {
-            const iframeSrc = getIFrameSrc();
-
-            // Bootstrap params stay: the handshake, the embed marker that
-            // picks the app shell, and the data sources it boots against.
-            expect(iframeSrc).toContain('hostAppUrl=');
-            expect(iframeSrc).toContain('isSearchEmbed=true');
-            expect(iframeSrc).toContain('dataSources');
-
-            // The rest of the view config goes over
-            // HostEvent.UpdateEmbedParams.
-            expect(iframeSrc).not.toContain('hideAction');
-            expect(iframeSrc).not.toContain('useLastSelectedDataSource');
-        });
-    });
-
     test('should pass dataSources parameter when dataSources array is provided', async () => {
         const searchBarEmbed = new SearchBarEmbed(getRootEl() as any, {
             ...defaultViewConfig,

package/src/embed/search.ts

@@ -546,7 +546,7 @@ export class SearchEmbed extends TsEmbed {
             excludeRuntimeParametersfromURL,
             excludeRuntimeFiltersfromURL,
         } = this.viewConfig;
-        const queryParams = this.getUrlQueryParamsObject();
+        const queryParams = this.getEmbedParamsObject();
         let query = '';
         const queryParamsString = getQueryParamString(queryParams, true);
         if (queryParamsString) {

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

@@ -71,6 +71,10 @@ import * as processData from '../utils/processData';
 jest.mock('../utils/processTrigger');
 
 const mockProcessTrigger = processTrigger as jest.Mock;
+
+const flushAnimationFrame = () => new Promise<void>((resolve) => {
+    requestAnimationFrame(() => resolve());
+});
 const mockHandleInterceptEvent = jest.spyOn(apiIntercept, 'handleInterceptEvent');
 const defaultViewConfig = {
     frameParams: {
@@ -2620,12 +2624,14 @@ 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('');
+            expect(preRenderWrapper.style.pointerEvents).toBe('auto');
             expect(preRenderWrapper.style.zIndex).toBe('');
 
             libEmbed.hidePreRender();
@@ -2662,7 +2668,7 @@ describe('Unit test case for ts embed', () => {
             const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
 
             expect(preRenderWrapper.style.opacity).toBe('');
-            expect(preRenderWrapper.style.pointerEvents).toBe('');
+            expect(preRenderWrapper.style.pointerEvents).toBe('auto');
             expect(preRenderWrapper.style.zIndex).toBe('');
         });
 
@@ -2835,6 +2841,211 @@ 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 tracking once the frame is hidden', async () => {
+                const { scroller, readPlaceholderTop } = mountInNestedScroller();
+
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    preRenderId: 'scroll-stops-on-hide',
+                    liveboardId: 'myLiveboardId',
+                });
+                libEmbed.preRender();
+                await waitFor(() => !!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 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();
@@ -3108,21 +3319,16 @@ 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();
@@ -6695,175 +6901,3 @@ 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');
-        expect(src).not.toContain('isPinboardV2Enabled');
-        expect(src).not.toContain('enableDataPanelV2');
-    });
-
-    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 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 full config over UpdateEmbedParams once the frame is ready', async () => {
-        await renderAndGetSrc(withPostMessage(lbConfig));
-
-        signalFrameReady();
-
-        await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
-                expect.any(Object),
-                HostEvent.UpdateEmbedParams,
-                expect.any(String),
-                expect.objectContaining({
-                    liveboardId,
-                    hiddenActions: [Action.Download],
-                    internalBlinkFlag: true,
-                    [Param.HideActions]: expect.arrayContaining([Action.Download]),
-                }),
-                undefined,
-            );
-        });
-    });
-
-    test('sends UpdateEmbedParams again every time the frame signals ready', async () => {
-        await renderAndGetSrc(withPostMessage(lbConfig));
-        signalFrameReady();
-        signalFrameReady();
-
-        await executeAfterWait(() => {
-            const updateCalls = mockProcessTrigger.mock.calls.filter(
-                (call) => call[1] === HostEvent.UpdateEmbedParams,
-            );
-            expect(updateCalls).toHaveLength(2);
-        });
-    });
-
-    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);
-        });
-
-        mockProcessTrigger.mockClear();
-        await embed.showPreRender();
-
-        await executeAfterWait(() => {
-            const updateCalls = mockProcessTrigger.mock.calls.filter(
-                (call) => call[1] === HostEvent.UpdateEmbedParams,
-            );
-            expect(updateCalls).toHaveLength(1);
-        });
-    });
-});