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

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

@@ -1409,6 +1409,40 @@ 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 as EventListener)({
+                        data: { type: 'xyz' },
+                        ports: [3000],
+                        source: null,
+                    } as any);
+                },
+            );
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'test' });
+            jest.spyOn(authService, 'fetchPreauthInfoService').mockResolvedValueOnce({
+                ok: true,
+                headers: new Headers({ 'content-type': 'application/json' }),
+                json: async () => ({}), // no .info field
+            } as any);
+            const iFrame: any = document.createElement('div');
+            jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValueOnce(true as any);
+            const tsEmbed = new SearchEmbed(getRootEl(), {});
+            iFrame.contentWindow = { postMessage: jest.fn() };
+            jest.spyOn(iFrame, 'addEventListener').mockImplementationOnce(
+                (event, handler) => { (handler as EventListener)({} as Event); },
+            );
+            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', () => {
@@ -2281,6 +2315,46 @@ describe('Unit test case for ts embed', () => {
             });
         });
 
+        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,
@@ -2665,6 +2739,45 @@ describe('Unit test case for ts embed', () => {
             (logger.error as any).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 as any).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 as any).mockRestore();
+        });
+
         describe('preRenderContainer', () => {
             it('should append preRenderWrapper to document.body when preRenderContainer is not set', async () => {
                 createRootEleForEmbed();
@@ -2794,9 +2907,10 @@ describe('Unit test case for ts embed', () => {
 
                 // 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 as any).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 as any).preRenderContainerEl).toBe(document.body);
 
                 customContainer.remove();
             });
@@ -2822,6 +2936,38 @@ describe('Unit test case for ts embed', () => {
                 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 as any).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 as any).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');
@@ -2925,6 +3071,45 @@ describe('Unit test case for ts embed', () => {
                 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 as any).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');
@@ -2953,6 +3138,557 @@ describe('Unit test case for ts embed', () => {
 
                 libEmbed.destroy();
             });
+
+            describe('connectPreRendered container init', () => {
+                beforeEach(() => {
+                    (window as any).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 as any).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 as any).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 as any).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 as any,
+                        'resolvePreRenderContainerTarget',
+                    );
+
+                    (connectingEmbed as any).connectPreRendered();
+
+                    expect((connectingEmbed as any).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 as any).connectPreRendered();
+
+                    expect((connectingEmbed as any).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 as any).connectPreRendered();
+
+                    expect((connectingEmbed as any).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 as any).connectPreRendered();
+
+                    expect((connectingEmbed as any).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 as any).connectPreRendered();
+
+                    expect((libEmbed as any).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 as any).__tsEmbed;
+
+                    const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                        preRenderId: 'connect-unstamped',
+                        liveboardId: 'myLiveboardId',
+                    });
+                    (connectingEmbed as any).connectPreRendered();
+
+                    // Falls back to the sentinel rather than crashing on the
+                    // missing owner, and warns about nothing.
+                    expect((connectingEmbed as any).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 as any).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 as any).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 as any).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();
+            });
         });
     });
 
@@ -4570,6 +5306,28 @@ 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 as any, '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, {} as any),
+        ).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', () => {
@@ -4580,6 +5338,10 @@ describe('PreRender replaceExistingPreRender scenarios', () => {
         });
     });
 
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+
     afterEach(() => {
         const rootEle = document.getElementById('myRoot');
         rootEle?.remove();
@@ -4725,6 +5487,52 @@ describe('Fullscreen change handler behavior', () => {
             );
         });
     });
+
+    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 as any).iFrame = { contentWindow: null };
+
+        const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
+        const loggerDebugSpy = jest.spyOn(logger, 'debug').mockImplementation(() => {});
+        const triggerSpy = jest.spyOn(embed, 'trigger' as any).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] as EventListener;
+
+        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', () => {
@@ -5315,5 +6123,79 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
 
             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,
+            } as any);
+            await embed.preRender();
+            await waitFor(
+                () => !!document.querySelector('#tsEmbed-pre-render-child-ph-nested-test'),
+            );
+
+            const hostElement = document.querySelector('#tsEmbedDiv') as HTMLElement;
+            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 as any
+            ).getPreRenderPlaceHolderElement() as HTMLDivElement;
+            expect(currentPlaceholder.parentElement).toBe(hostElement);
+
+            embed.destroy();
+        });
+    });
+
+    describe('trigger typing contracts (compile-time)', () => {
+        // Guards the BASE TsEmbed.trigger — the implementation every
+        // non-Liveboard embed (SearchEmbed, AppEmbed, ConversationEmbed, …)
+        // calls. LiveboardEmbed's override is covered in liveboard.spec.ts;
+        // this locks the base defaults so a "lint fix" that drops them here
+        // can't silently de-type every embed except Liveboard.
+        // Enforced by ts-jest at compile time.
+        type IsAny<T> = 0 extends 1 & T ? true : false;
+        type Extends<A, B> = A extends B ? true : false;
+
+        it('infers typed response for no-payload calls on the base trigger', () => {
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+
+            const getTabs = () => searchEmbed.trigger(HostEvent.GetTabs);
+            type TabsResponse = Awaited<ReturnType<typeof getTabs>>;
+            const tabsIsTyped: IsAny<TabsResponse> = false;
+            const tabsHasContractFields: Extends<
+                TabsResponse,
+                { numberOfTabs: number; orderedTabIds: string[] }
+            > = true;
+            const probeUnknownField = (r: TabsResponse) =>
+                // @ts-expect-error — field not on the GetTabs contract (was silent when `any`)
+                r.tabCount;
+            void probeUnknownField;
+
+            const reload = () => searchEmbed.trigger(HostEvent.Reload);
+            type ReloadResponse = Awaited<ReturnType<typeof reload>>;
+            const reloadStaysAny: IsAny<ReloadResponse> = true;
+
+            expect([tabsIsTyped, tabsHasContractFields, reloadStaysAny])
+                .toEqual([false, true, true]);
+        });
     });
 });