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

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

@@ -2267,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();
@@ -2369,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 () => {
@@ -2391,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');
@@ -2476,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');
@@ -2499,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', () => {
@@ -4441,5 +4959,21 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
             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