@thoughtspot/visual-embed-sdk 1.50.0 → 1.51.0-test

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

@@ -1170,6 +1170,32 @@ describe('Unit test case for ts embed', () => {
             const { mockGetPreauthInfo } = await setup(true, 123);
             expect(mockGetPreauthInfo).toHaveBeenCalledTimes(0);
         });
+        test('should NOT trigger InfoSuccess when getPreauthInfo resolves with no .info field', async () => {
+            jest.spyOn(window, 'addEventListener').mockImplementationOnce((event, handler) => {
+                handler({
+                    data: { type: 'xyz' },
+                    ports: [3000],
+                    source: null,
+                });
+            });
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'test' });
+            jest.spyOn(authService, 'fetchPreauthInfoService').mockResolvedValueOnce({
+                ok: true,
+                headers: new Headers({ 'content-type': 'application/json' }),
+                json: async () => ({}), // no .info field
+            });
+            const iFrame = document.createElement('div');
+            jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValueOnce(true);
+            const tsEmbed = new SearchEmbed(getRootEl(), {});
+            iFrame.contentWindow = { postMessage: jest.fn() };
+            jest.spyOn(iFrame, 'addEventListener').mockImplementationOnce((event, handler) => { handler({}); });
+            jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
+            await tsEmbed.render();
+            await executeAfterWait(() => {
+                const infoSuccessCall = mockProcessTrigger.mock.calls.find((call) => call[1] === HostEvent.InfoSuccess);
+                expect(infoSuccessCall).toBeUndefined();
+            });
+        });
     });
     describe('Preauth Cache for FullAppEmbed with PrimaryNavBar', () => {
         beforeAll(() => {
@@ -1893,6 +1919,43 @@ describe('Unit test case for ts embed', () => {
                 orgId: overrideOrgId,
             });
         });
+        it('Sets the overrideHistoryState param', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                overrideHistoryState: true,
+            });
+            await appEmbed.render();
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                overrideHistoryState: true,
+            });
+        });
+        it('Sets the overrideHistoryState param to false', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                overrideHistoryState: false,
+            });
+            await appEmbed.render();
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                overrideHistoryState: false,
+            });
+        });
+        it('Should not add overrideHistoryState param when it is undefined', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+            });
+            await appEmbed.render();
+            const url = getIFrameSrc();
+            expect(url).not.toContain('overrideHistoryState');
+        });
         it('Should not add contextMenuEnabledOnWhichClick flag to the iframe src when it is not passed', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 ...defaultViewConfig,
@@ -2204,6 +2267,37 @@ describe('Unit test case for ts embed', () => {
             expect(logger.error).toHaveBeenCalledWith('PreRender should be called before using syncPreRenderStyle');
             logger.error.mockClear();
         });
+        it('should skip syncing styles when the placeholder is detached', async () => {
+            createRootEleForEmbed();
+            jest.spyOn(logger, 'debug').mockImplementation(jest.fn());
+            const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                liveboardId: 'myLiveboardId',
+                preRenderId: 'placeholder-detached',
+                doNotTrackPreRenderSize: true,
+            });
+            libEmbed.preRender();
+            await waitFor(() => !!getIFrameEl());
+            await libEmbed.showPreRender();
+            const preRenderIds = libEmbed.getPreRenderIds();
+            const wrapper = document.getElementById(preRenderIds.wrapper);
+            const placeholder = document.getElementById(preRenderIds.placeHolder);
+            const rectSpy = jest.spyOn(placeholder, 'getBoundingClientRect');
+            wrapper.style.top = '42px';
+            wrapper.style.height = '111px';
+            logger.debug.mockClear();
+            // Simulate the host subtree being unmounted: the placeholder is no
+            // longer connected to the document.
+            placeholder.remove();
+            libEmbed.syncPreRenderStyle();
+            expect(logger.debug).toHaveBeenCalledWith('syncPreRenderStyle skipped: placeholder is detached');
+            // The detached node is never measured, so the wrapper keeps its
+            // last known geometry instead of collapsing to a stale rect.
+            expect(rectSpy).not.toHaveBeenCalled();
+            expect(wrapper.style.top).toBe('42px');
+            expect(wrapper.style.height).toBe('111px');
+            libEmbed.destroy();
+            logger.debug.mockRestore();
+        });
         describe('preRenderContainer', () => {
             it('should append preRenderWrapper to document.body when preRenderContainer is not set', async () => {
                 createRootEleForEmbed();
@@ -2306,9 +2400,10 @@ describe('Unit test case for ts embed', () => {
                 libEmbed.destroy();
                 // Reverts to the exact value the container had before.
                 expect(customContainer.style.position).toBe('static');
-                // The container reference is dropped so a destroyed embed does
-                // not pin the (possibly detached) element in memory.
-                expect(libEmbed.preRenderContainerEl).toBeNull();
+                // The custom container reference is dropped (back to the default
+                // body) so a destroyed embed does not pin the (possibly
+                // detached) element in memory.
+                expect(libEmbed.preRenderContainerEl).toBe(document.body);
                 customContainer.remove();
             });
             it('should not touch the container position when it is already positioned', async () => {
@@ -2328,6 +2423,30 @@ describe('Unit test case for ts embed', () => {
                 expect(customContainer.style.position).toBe('absolute');
                 customContainer.remove();
             });
+            it('should default preRenderContainerEl to document.body before rendering', () => {
+                createRootEleForEmbed();
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    liveboardId: 'myLiveboardId',
+                });
+                // document.body is the "no custom container" sentinel, so the
+                // field is never null and needs no null-guarding downstream.
+                expect(libEmbed.preRenderContainerEl).toBe(document.body);
+            });
+            it('should leave document.body untouched on destroy when no custom container is set', async () => {
+                createRootEleForEmbed();
+                const originalBodyPosition = document.body.style.position;
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    preRenderId: 'container-body-destroy',
+                    liveboardId: 'myLiveboardId',
+                });
+                await libEmbed.preRender();
+                expect(libEmbed.preRenderContainerEl).toBe(document.body);
+                libEmbed.destroy();
+                // The body sentinel must never be treated as a custom container:
+                // no position override to apply and none to restore.
+                expect(document.body.style.position).toBe(originalBodyPosition);
+                expect(document.body.dataset.tsEmbedOriginalPosition).toBeUndefined();
+            });
             it('should keep the container positioned on destroy while another preRender wrapper remains', async () => {
                 createRootEleForEmbed();
                 const customContainer = document.createElement('div');
@@ -2413,6 +2532,38 @@ describe('Unit test case for ts embed', () => {
                 libEmbed.destroy();
                 newContainer.remove();
             });
+            it('should position the newly resolved container after a remount, not the stale one', async () => {
+                createRootEleForEmbed();
+                const oldContainer = document.createElement('div');
+                oldContainer.id = 'reposition-remount-container';
+                oldContainer.style.position = 'static';
+                document.body.appendChild(oldContainer);
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    preRenderId: 'container-remount-position',
+                    liveboardId: 'myLiveboardId',
+                    preRenderContainer: '#reposition-remount-container',
+                    doNotTrackPreRenderSize: true,
+                });
+                libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                await libEmbed.showPreRender();
+                expect(oldContainer.style.position).toBe('relative');
+                oldContainer.remove();
+                const newContainer = document.createElement('div');
+                newContainer.id = 'reposition-remount-container';
+                newContainer.style.position = 'static';
+                document.body.appendChild(newContainer);
+                libEmbed.syncPreRenderStyle();
+                // applyPreRenderContainerPositioning() reads preRenderContainerEl
+                // instead of taking the container as an argument, so reconcile has
+                // to assign the field before calling it — otherwise the override
+                // lands on the detached node and the fresh one stays static.
+                expect(libEmbed.preRenderContainerEl).toBe(newContainer);
+                expect(newContainer.style.position).toBe('relative');
+                expect(newContainer.dataset.tsEmbedOriginalPosition).toBe('static');
+                libEmbed.destroy();
+                newContainer.remove();
+            });
             it('should leave an element-passed container untouched when it is detached', async () => {
                 createRootEleForEmbed();
                 const container = document.createElement('div');
@@ -2436,6 +2587,436 @@ describe('Unit test case for ts embed', () => {
                 expect(container.contains(wrapper)).toBe(true);
                 libEmbed.destroy();
             });
+            describe('connectPreRendered container init', () => {
+                beforeEach(() => {
+                    window.ResizeObserver = jest.fn().mockImplementation(() => ({
+                        disconnect: jest.fn(),
+                        observe: jest.fn(),
+                        unobserve: jest.fn(),
+                    }));
+                });
+                it('should resolve preRenderContainerEl when connecting to an existing pre-render', async () => {
+                    createRootEleForEmbed();
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-default',
+                        liveboardId: 'myLiveboardId',
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-default',
+                        liveboardId: 'myLiveboardId',
+                    });
+                    await connectingEmbed.showPreRender();
+                    expect(connectingEmbed.preRenderContainerEl).not.toBeNull();
+                    firstEmbed.destroy();
+                });
+                it('should fall back to document.body when no preRenderContainer is configured on the connecting embed', async () => {
+                    createRootEleForEmbed();
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-body',
+                        liveboardId: 'myLiveboardId',
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-body',
+                        liveboardId: 'myLiveboardId',
+                    });
+                    await connectingEmbed.showPreRender();
+                    expect(connectingEmbed.preRenderContainerEl).toBe(document.body);
+                    firstEmbed.destroy();
+                });
+                it('should resolve a custom preRenderContainer on the connecting embed', async () => {
+                    createRootEleForEmbed();
+                    const customContainer = document.createElement('div');
+                    customContainer.id = 'connect-custom-container';
+                    document.body.appendChild(customContainer);
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-custom',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-custom',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await connectingEmbed.showPreRender();
+                    expect(connectingEmbed.preRenderContainerEl).toBe(customContainer);
+                    firstEmbed.destroy();
+                    customContainer.remove();
+                });
+                it('should apply container positioning when the connecting embed resolves a static container', async () => {
+                    createRootEleForEmbed();
+                    const customContainer = document.createElement('div');
+                    customContainer.id = 'connect-static-container';
+                    customContainer.style.position = 'static';
+                    document.body.appendChild(customContainer);
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-static',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    // Reset position to static so the connecting embed also triggers the guard.
+                    customContainer.style.position = 'static';
+                    delete customContainer.dataset['preRenderContainerOriginalPosition'];
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-init-static',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await connectingEmbed.showPreRender();
+                    expect(customContainer.style.position).toBe('relative');
+                    firstEmbed.destroy();
+                    connectingEmbed.destroy();
+                    customContainer.remove();
+                });
+                it('should inherit the container from the pre-rendering embed instead of re-resolving it', async () => {
+                    createRootEleForEmbed();
+                    const customContainer = document.createElement('div');
+                    customContainer.id = 'connect-inherit-container';
+                    document.body.appendChild(customContainer);
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-no-re-resolve',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    // No preRenderContainer here: the container belongs to the
+                    // PreRender component and is adopted as-is.
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-no-re-resolve',
+                        liveboardId: 'myLiveboardId',
+                    });
+                    const resolveSpy = jest.spyOn(connectingEmbed, 'resolvePreRenderContainerTarget');
+                    connectingEmbed.connectPreRendered();
+                    expect(connectingEmbed.preRenderContainerEl).toBe(customContainer);
+                    expect(resolveSpy).not.toHaveBeenCalled();
+                    firstEmbed.destroy();
+                    customContainer.remove();
+                });
+                it('should warn and ignore a preRenderContainer passed on the connecting embed', async () => {
+                    createRootEleForEmbed();
+                    const ownerContainer = document.createElement('div');
+                    ownerContainer.id = 'connect-owner-container';
+                    const otherContainer = document.createElement('div');
+                    otherContainer.id = 'connect-other-container';
+                    document.body.appendChild(ownerContainer);
+                    document.body.appendChild(otherContainer);
+                    const warnSpy = jest.spyOn(logger, 'warn').mockImplementation(() => undefined);
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-container-warn',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: ownerContainer,
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-container-warn',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: otherContainer,
+                    });
+                    connectingEmbed.connectPreRendered();
+                    expect(connectingEmbed.preRenderContainerEl).toBe(ownerContainer);
+                    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('preRenderContainer is applied only by'));
+                    warnSpy.mockRestore();
+                    firstEmbed.destroy();
+                    ownerContainer.remove();
+                    otherContainer.remove();
+                });
+                it('should not warn when the connecting embed passes the same container element', async () => {
+                    createRootEleForEmbed();
+                    const customContainer = document.createElement('div');
+                    customContainer.id = 'connect-same-element-container';
+                    document.body.appendChild(customContainer);
+                    const warnSpy = jest.spyOn(logger, 'warn').mockImplementation(() => undefined);
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-same-element',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    // Same config on both components — the value is redundant but
+                    // not wrong, so nagging about it would be noise.
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-same-element',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    connectingEmbed.connectPreRendered();
+                    expect(connectingEmbed.preRenderContainerEl).toBe(customContainer);
+                    expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('preRenderContainer is applied only by'));
+                    warnSpy.mockRestore();
+                    firstEmbed.destroy();
+                    customContainer.remove();
+                });
+                it('should not warn when the connecting embed passes a selector for the same container', async () => {
+                    createRootEleForEmbed();
+                    const customContainer = document.createElement('div');
+                    customContainer.id = 'connect-same-selector-container';
+                    document.body.appendChild(customContainer);
+                    const warnSpy = jest.spyOn(logger, 'warn').mockImplementation(() => undefined);
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-same-selector',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    // A selector that resolves to the owner's element is the same
+                    // container, so the comparison must be by resolved node.
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-same-selector',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: '#connect-same-selector-container',
+                    });
+                    connectingEmbed.connectPreRendered();
+                    expect(connectingEmbed.preRenderContainerEl).toBe(customContainer);
+                    expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('preRenderContainer is applied only by'));
+                    warnSpy.mockRestore();
+                    firstEmbed.destroy();
+                    customContainer.remove();
+                });
+                it('should keep its own container when the same instance owns the pre-render', async () => {
+                    createRootEleForEmbed();
+                    const customContainer = document.createElement('div');
+                    customContainer.id = 'connect-self-container';
+                    document.body.appendChild(customContainer);
+                    const warnSpy = jest.spyOn(logger, 'warn').mockImplementation(() => undefined);
+                    const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-self',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await libEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    // preRender() then render() on one instance: it owns the
+                    // wrapper, so there is nothing to inherit and its own
+                    // preRenderContainer is entirely legitimate.
+                    libEmbed.connectPreRendered();
+                    expect(libEmbed.preRenderContainerEl).toBe(customContainer);
+                    expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('preRenderContainer is applied only by'));
+                    warnSpy.mockRestore();
+                    libEmbed.destroy();
+                    customContainer.remove();
+                });
+                it('should stay on document.body when the wrapper has no owning embed', async () => {
+                    createRootEleForEmbed();
+                    const customContainer = document.createElement('div');
+                    customContainer.id = 'connect-unstamped-container';
+                    document.body.appendChild(customContainer);
+                    const warnSpy = jest.spyOn(logger, 'warn').mockImplementation(() => undefined);
+                    const firstEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-unstamped',
+                        liveboardId: 'myLiveboardId',
+                        preRenderContainer: customContainer,
+                    });
+                    await firstEmbed.preRender();
+                    await waitFor(() => !!getIFrameEl());
+                    // Simulate a wrapper with no live embed behind it: the
+                    // __tsEmbed stamp used to locate the owner is gone, so there
+                    // is no container to inherit.
+                    const wrapper = document.getElementById(firstEmbed.getPreRenderIds().wrapper);
+                    delete wrapper.__tsEmbed;
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-unstamped',
+                        liveboardId: 'myLiveboardId',
+                    });
+                    connectingEmbed.connectPreRendered();
+                    // Falls back to the sentinel rather than crashing on the
+                    // missing owner, and warns about nothing.
+                    expect(connectingEmbed.preRenderContainerEl).toBe(document.body);
+                    expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('preRenderContainer is applied only by'));
+                    warnSpy.mockRestore();
+                    firstEmbed.destroy();
+                    customContainer.remove();
+                });
+            });
+        });
+        describe('preRenderConfig', () => {
+            beforeEach(() => {
+                window.ResizeObserver = jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: jest.fn(),
+                    unobserve: jest.fn(),
+                }));
+            });
+            it('should use default z-index of -1000 when preRenderConfig is not set', async () => {
+                createRootEleForEmbed();
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    preRenderId: 'pre-render-config-defaults',
+                    liveboardId: 'myLiveboardId',
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                const preRenderIds = libEmbed.getPreRenderIds();
+                const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
+                expect(preRenderWrapper.style.zIndex).toBe('-1000');
+                libEmbed.destroy();
+            });
+            it('should apply custom zIndex from preRenderConfig when hidden', async () => {
+                createRootEleForEmbed();
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    preRenderId: 'pre-render-config-custom-z-index',
+                    liveboardId: 'myLiveboardId',
+                    preRenderConfig: {
+                        zIndex: -10,
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                const preRenderIds = libEmbed.getPreRenderIds();
+                const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
+                expect(preRenderWrapper.style.zIndex).toBe('-10');
+                libEmbed.destroy();
+            });
+            it('should clear z-index on showPreRender and restore custom zIndex on hidePreRender', async () => {
+                createRootEleForEmbed();
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    preRenderId: 'pre-render-config-cycle',
+                    liveboardId: 'myLiveboardId',
+                    preRenderConfig: {
+                        zIndex: -5,
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                const preRenderIds = libEmbed.getPreRenderIds();
+                const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
+                expect(preRenderWrapper.style.zIndex).toBe('-5');
+                libEmbed.showPreRender();
+                expect(preRenderWrapper.style.zIndex).toBe('');
+                libEmbed.hidePreRender();
+                expect(preRenderWrapper.style.zIndex).toBe('-5');
+                libEmbed.destroy();
+            });
+            it('should use preRenderConfig.preRenderId to identify the pre-render instance', async () => {
+                createRootEleForEmbed();
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    liveboardId: 'myLiveboardId',
+                    preRenderConfig: {
+                        preRenderId: 'config-level-id',
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                const preRenderIds = libEmbed.getPreRenderIds();
+                expect(preRenderIds.wrapper).toContain('config-level-id');
+                expect(document.getElementById(preRenderIds.wrapper)).not.toBeNull();
+                libEmbed.destroy();
+            });
+            it('should prefer preRenderConfig.preRenderId over top-level preRenderId', async () => {
+                createRootEleForEmbed();
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    liveboardId: 'myLiveboardId',
+                    preRenderId: 'top-level-id',
+                    preRenderConfig: {
+                        preRenderId: 'config-level-id',
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                const preRenderIds = libEmbed.getPreRenderIds();
+                expect(preRenderIds.wrapper).toContain('config-level-id');
+                expect(preRenderIds.wrapper).not.toContain('top-level-id');
+                libEmbed.destroy();
+            });
+            it('should mount the wrapper into preRenderConfig.preRenderContainer', async () => {
+                createRootEleForEmbed();
+                const customContainer = document.createElement('div');
+                customContainer.id = 'config-level-container';
+                document.body.appendChild(customContainer);
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    liveboardId: 'myLiveboardId',
+                    preRenderConfig: {
+                        preRenderId: 'container-via-config',
+                        preRenderContainer: '#config-level-container',
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                const preRenderIds = libEmbed.getPreRenderIds();
+                const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
+                expect(customContainer.contains(preRenderWrapper)).toBe(true);
+                libEmbed.destroy();
+                customContainer.remove();
+            });
+            it('should prefer preRenderConfig.preRenderContainer over top-level preRenderContainer', async () => {
+                createRootEleForEmbed();
+                const topContainer = document.createElement('div');
+                topContainer.id = 'top-level-container';
+                document.body.appendChild(topContainer);
+                const configContainer = document.createElement('div');
+                configContainer.id = 'config-level-container-2';
+                document.body.appendChild(configContainer);
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    liveboardId: 'myLiveboardId',
+                    preRenderContainer: '#top-level-container',
+                    preRenderConfig: {
+                        preRenderId: 'container-precedence',
+                        preRenderContainer: '#config-level-container-2',
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                const preRenderIds = libEmbed.getPreRenderIds();
+                const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
+                expect(configContainer.contains(preRenderWrapper)).toBe(true);
+                expect(topContainer.contains(preRenderWrapper)).toBe(false);
+                libEmbed.destroy();
+                topContainer.remove();
+                configContainer.remove();
+            });
+            it('should not attach ResizeObserver when preRenderConfig.doNotTrackPreRenderSize is true', async () => {
+                createRootEleForEmbed();
+                const observeMock = jest.fn();
+                window.ResizeObserver = jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: observeMock,
+                    unobserve: jest.fn(),
+                }));
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    liveboardId: 'myLiveboardId',
+                    preRenderConfig: {
+                        preRenderId: 'no-track-via-config',
+                        doNotTrackPreRenderSize: true,
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                libEmbed.showPreRender();
+                expect(observeMock).not.toHaveBeenCalled();
+                libEmbed.destroy();
+            });
+            it('should prefer preRenderConfig.doNotTrackPreRenderSize over top-level doNotTrackPreRenderSize', async () => {
+                createRootEleForEmbed();
+                const observeMock = jest.fn();
+                window.ResizeObserver = jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: observeMock,
+                    unobserve: jest.fn(),
+                }));
+                const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                    liveboardId: 'myLiveboardId',
+                    doNotTrackPreRenderSize: false,
+                    preRenderConfig: {
+                        preRenderId: 'no-track-precedence',
+                        doNotTrackPreRenderSize: true,
+                    },
+                });
+                await libEmbed.preRender();
+                await waitFor(() => !!getIFrameEl());
+                libEmbed.showPreRender();
+                expect(observeMock).not.toHaveBeenCalled();
+                libEmbed.destroy();
+            });
         });
     });
     describe('IdleSessionTimeout embedEvent for TrustedAuthTokenCookieless authType with autoLogin true', () => {
@@ -3723,6 +4304,20 @@ describe('Trigger method edge cases', () => {
             expect(result).toBeNull();
         });
     });
+    test('isValidationError catch: handleError called with embedErrorDetails and error is rethrown', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const handleErrorSpy = jest.spyOn(searchEmbed, 'handleError').mockImplementation(() => { });
+        await searchEmbed.render();
+        // First processTrigger call is getAvailableUIPassthroughKeys for DrillDown
+        mockProcessTrigger.mockResolvedValueOnce([
+            { value: { keys: Object.values(UIPassthroughEvent) } },
+        ]);
+        // DrillDown with no points → throwDrillDownValidationError → isValidationError=true
+        await expect(searchEmbed.trigger(HostEvent.DrillDown, {})).rejects.toThrow('DrillDown requires a valid points object');
+        expect(handleErrorSpy).toHaveBeenCalledWith(expect.objectContaining({
+            data: expect.objectContaining({ code: EmbedErrorCodes.HOST_EVENT_VALIDATION }),
+        }));
+    });
 });
 describe('PreRender replaceExistingPreRender scenarios', () => {
     beforeAll(() => {
@@ -3731,6 +4326,9 @@ describe('PreRender replaceExistingPreRender scenarios', () => {
             authType: AuthType.None,
         });
     });
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
     afterEach(() => {
         const rootEle = document.getElementById('myRoot');
         rootEle === null || rootEle === void 0 ? void 0 : rootEle.remove();
@@ -3838,6 +4436,40 @@ describe('Fullscreen change handler behavior', () => {
             expect(mockProcessTrigger).not.toHaveBeenCalledWith(expect.any(Object), HostEvent.ExitPresentMode, expect.any(String), expect.any(Object));
         });
     });
+    test('disableFullscreenPresentation undefined defaults to true — no fullscreenchange listener registered', () => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+            // disableFullscreenPresentation not set → defaults to true via ?? true
+        });
+        const embed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
+        embed['setupFullscreenChangeHandler']();
+        expect(addEventListenerSpy).not.toHaveBeenCalledWith('fullscreenchange', expect.any(Function));
+        addEventListenerSpy.mockRestore();
+        // Restore for other tests in this describe
+        init({ thoughtSpotHost: 'tshost', authType: AuthType.None, disableFullscreenPresentation: false });
+    });
+    test('fullscreenchange fires but iFrame.contentWindow is null — trigger NOT called, debug log emitted', () => {
+        const embed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        // Give the embed a fake iFrame with null contentWindow
+        embed.iFrame = { contentWindow: null };
+        const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
+        const loggerDebugSpy = jest.spyOn(logger, 'debug').mockImplementation(() => { });
+        const triggerSpy = jest.spyOn(embed, 'trigger').mockImplementation(() => Promise.resolve(null));
+        embed['setupFullscreenChangeHandler']();
+        // Capture the registered handler directly instead of dispatching to document
+        const fullscreenCall = addEventListenerSpy.mock.calls.find((c) => c[0] === 'fullscreenchange');
+        expect(fullscreenCall).toBeTruthy();
+        const handler = fullscreenCall[1];
+        Object.defineProperty(document, 'fullscreenElement', { value: null, writable: true, configurable: true });
+        handler(new Event('fullscreenchange'));
+        expect(triggerSpy).not.toHaveBeenCalled();
+        expect(loggerDebugSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping ExitPresentMode'));
+        addEventListenerSpy.mockRestore();
+        loggerDebugSpy.mockRestore();
+        triggerSpy.mockRestore();
+    });
 });
 describe('ShowPreRender with UpdateEmbedParams', () => {
     const setupPreRenderTest = async (preRenderId, initialConfig) => {
@@ -4294,6 +4926,54 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
             expect(placeholderEle.parentElement).not.toBeNull();
             embed.destroy();
         });
+        // showPreRender located the stale placeholder with a subtree-wide
+        // querySelector but removed it with hostElement.removeChild(), which
+        // only accepts direct children. With fullHeight the placeholder can be
+        // nested deeper than a direct child, so removeChild threw
+        // "NotFoundError: Failed to execute 'removeChild' on 'Node'".
+        it('showPreRender removes a placeholder nested below a direct child without throwing', async () => {
+            createRootEleForEmbed();
+            const embed = new LiveboardEmbed('#tsEmbedDiv', {
+                preRenderId: 'ph-nested-test',
+                liveboardId: 'lb-id',
+                fullHeight: true,
+            });
+            await embed.preRender();
+            await waitFor(() => !!document.querySelector('#tsEmbed-pre-render-child-ph-nested-test'));
+            const hostElement = document.querySelector('#tsEmbedDiv');
+            const placeHolderId = 'tsEmbed-pre-render-placeholder-ph-nested-test';
+            // Simulate the fullHeight layout where the placeholder ends up as
+            // a grandchild of the host element rather than a direct child.
+            const intermediateWrapper = document.createElement('div');
+            const staleNestedPlaceholder = document.createElement('div');
+            staleNestedPlaceholder.id = placeHolderId;
+            intermediateWrapper.appendChild(staleNestedPlaceholder);
+            hostElement.appendChild(intermediateWrapper);
+            expect(hostElement.querySelector(`#${placeHolderId}`)).toBe(staleNestedPlaceholder);
+            // Before the fix this threw NotFoundError.
+            await expect(embed.showPreRender()).resolves.toBeDefined();
+            // The stale nested placeholder is gone; the fresh one is a direct child.
+            expect(staleNestedPlaceholder.isConnected).toBe(false);
+            const currentPlaceholder = embed.getPreRenderPlaceHolderElement();
+            expect(currentPlaceholder.parentElement).toBe(hostElement);
+            embed.destroy();
+        });
+    });
+    describe('trigger typing contracts (compile-time)', () => {
+        it('infers typed response for no-payload calls on the base trigger', () => {
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            const getTabs = () => searchEmbed.trigger(HostEvent.GetTabs);
+            const tabsIsTyped = false;
+            const tabsHasContractFields = true;
+            const probeUnknownField = (r) => 
+            // @ts-expect-error — field not on the GetTabs contract (was silent when `any`)
+            r.tabCount;
+            void probeUnknownField;
+            const reload = () => searchEmbed.trigger(HostEvent.Reload);
+            const reloadStaysAny = true;
+            expect([tabsIsTyped, tabsHasContractFields, reloadStaysAny])
+                .toEqual([false, true, true]);
+        });
     });
 });
 //# sourceMappingURL=ts-embed.spec.js.map