@thoughtspot/visual-embed-sdk 1.51.0 → 1.51.1

package/lib/src/embed/app.spec.js

@@ -152,6 +152,7 @@ describe('App embed tests', () => {
             [Page.SpotIQ]: 'insights/results',
             [Page.Monitor]: 'insights/monitor-alerts',
             [Page.Collections]: 'collections',
+            [Page.LiveboardSchedules]: 'home/liveboard-schedules',
         };
         const pageIds = Object.keys(pageRouteMap);
         for (let i = 0; i < pageIds.length; i++) {
@@ -179,6 +180,7 @@ describe('App embed tests', () => {
             [Page.SpotIQ]: 'home/spotiq-analysis',
             [Page.Monitor]: 'home/monitor-alerts',
             [Page.Collections]: 'collections',
+            [Page.LiveboardSchedules]: 'home/liveboard-schedules',
         };
         const pageIdsForModularHomes = Object.keys(pageRouteMapForModularHome);
         for (let i = 0; i < pageIdsForModularHomes.length; i++) {
@@ -286,6 +288,16 @@ describe('App embed tests', () => {
             expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&enable2ColumnLayout=true&navigationVersion=v3&homepageVersion=v3${defaultParamsPost}#/home`);
         });
     });
+    test('should set isLiveboardAlwaysOn12ColLayout to true in url', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            isLiveboardAlwaysOn12ColLayout: true,
+        });
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&isLiveboardAlwaysOn12ColLayout=true&navigationVersion=v3&homepageVersion=v3${defaultParamsPost}#/home`);
+        });
+    });
     test('should set coverAndFilterOptionInPDF to false in url', async () => {
         const appEmbed = new AppEmbed(getRootEl(), {
             ...defaultViewConfig,
@@ -306,6 +318,16 @@ describe('App embed tests', () => {
             expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&isLiveboardStylingAndGroupingEnabled=true&navigationVersion=v3&homepageVersion=v3${defaultParamsPost}#/home`);
         });
     });
+    test('should set liveboardGutter in url', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardGutter: 8,
+        });
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&liveboardGutter=8&navigationVersion=v3&homepageVersion=v3${defaultParamsPost}#/home`);
+        });
+    });
     test('should set isThisPeriodInDateFiltersEnabled to true in url', async () => {
         const appEmbed = new AppEmbed(getRootEl(), {
             ...defaultViewConfig,
@@ -546,6 +568,33 @@ describe('App embed tests', () => {
             });
         });
     });
+    test('should include starterPrompts in APP_INIT embedParams', async () => {
+        const starterPrompts = {
+            enable: true,
+            quick: {
+                label: 'Quick',
+                questions: [
+                    { label: 'Q1', prompt: 'P1' },
+                    { label: 'Q2', prompt: 'P2' },
+                ],
+            },
+            research: { label: 'Research' },
+        };
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            spotterChatConfig: { starterPrompts },
+        });
+        mockMessageChannel();
+        appEmbed.render();
+        const mockPort = { postMessage: jest.fn() };
+        await executeAfterWait(() => {
+            postMessageToParent(getIFrameEl().contentWindow, { type: EmbedEvent.APP_INIT, data: {} }, mockPort);
+        });
+        await executeAfterWait(() => {
+            expect(mockPort.postMessage.mock.calls[0][0].data.embedParams.starterPrompts)
+                .toEqual(starterPrompts);
+        });
+    });
     test('should pass brandHeadline through spotterVizConfig in APP_INIT', async () => {
         const spotterViz = { brandName: 'MyBrand', brandHeadline: "Hi, there! I'm" };
         const appEmbed = new AppEmbed(getRootEl(), {
@@ -722,7 +771,41 @@ describe('App embed tests', () => {
         });
         appEmbed.render();
         await executeAfterWait(() => {
-            expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&enableStarterPrompts=true${defaultParamsPost}#/home`);
+            expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&enableStarterPrompts=true&navigationVersion=v3&homepageVersion=v3${defaultParamsPost}#/home`);
+        });
+    });
+    test('should set openSpotterOnLiveboardByDefault to true in url', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            spotterChatConfig: { openSpotterOnLiveboardByDefault: true },
+        });
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                openSpotterOnLiveboardByDefault: 'true',
+            });
+        });
+    });
+    test('should set openSpotterOnLiveboardByDefault to false when explicitly disabled', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            spotterChatConfig: { openSpotterOnLiveboardByDefault: false },
+        });
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                openSpotterOnLiveboardByDefault: 'false',
+            });
+        });
+    });
+    test('should not set openSpotterOnLiveboardByDefault when it is not configured', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            spotterChatConfig: { enableStarterPrompts: true },
+        });
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expect(getIFrameSrc()).not.toContain('openSpotterOnLiveboardByDefault');
         });
     });
     test('should set spotterFileUploadFileTypes in url', async () => {
@@ -1499,6 +1582,175 @@ describe('App embed tests', () => {
                 expect(iframeSrc).toContain('isFullHeightPinboard=true');
             }, 100);
         });
+        test('should default lazy loading flags to true when fullHeight is enabled', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+            });
+            expect(appEmbed.viewConfig.lazyLoadingForFullHeight).toBe(true);
+            expect(appEmbed.viewConfig.enableScrollableContainerLazyLoading).toBe(true);
+            expect(appEmbed.viewConfig.lazyLoadingMargin).toBe('500px 0px');
+            await appEmbed.render();
+            await executeAfterWait(() => {
+                const iframeSrc = getIFrameSrc();
+                expect(iframeSrc).toContain('isLazyLoadingForEmbedEnabled=true');
+                expect(iframeSrc).toContain('isFullHeightPinboard=true');
+                expect(iframeSrc).toContain('rootMarginForLazyLoad=500px%200px');
+            }, 100);
+        });
+        test('should not default lazy loading flags when fullHeight is not enabled', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+            });
+            expect(appEmbed.viewConfig.lazyLoadingForFullHeight).toBeUndefined();
+            expect(appEmbed.viewConfig.enableScrollableContainerLazyLoading).toBeUndefined();
+            expect(appEmbed.viewConfig.lazyLoadingMargin).toBeUndefined();
+        });
+        test('should not write the defaults back onto the caller view config', async () => {
+            const callerViewConfig = {
+                ...defaultViewConfig,
+                fullHeight: true,
+            };
+            new AppEmbed(getRootEl(), callerViewConfig);
+            expect(callerViewConfig.lazyLoadingForFullHeight).toBeUndefined();
+            expect(callerViewConfig.enableScrollableContainerLazyLoading).toBeUndefined();
+            expect(callerViewConfig.lazyLoadingMargin).toBeUndefined();
+        });
+        test('should not default lazy loading flags when fullHeight is explicitly false', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: false,
+            });
+            expect(appEmbed.viewConfig.lazyLoadingForFullHeight).toBeUndefined();
+            expect(appEmbed.viewConfig.enableScrollableContainerLazyLoading).toBeUndefined();
+            expect(appEmbed.viewConfig.lazyLoadingMargin).toBeUndefined();
+        });
+        test('should default lazyLoadingMargin when lazyLoadingForFullHeight is set explicitly', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+                lazyLoadingForFullHeight: true,
+            });
+            expect(appEmbed.viewConfig.lazyLoadingMargin).toBe(config.DEFAULT_LAZY_LOADING_MARGIN);
+            await appEmbed.render();
+            await executeAfterWait(() => {
+                expect(getIFrameSrc()).toContain('rootMarginForLazyLoad=500px%200px');
+            }, 100);
+        });
+        test('should let an explicit lazyLoadingMargin win over the default', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+                lazyLoadingMargin: '250px',
+            });
+            await appEmbed.render();
+            await executeAfterWait(() => {
+                const iframeSrc = getIFrameSrc();
+                expect(iframeSrc).toContain('rootMarginForLazyLoad=250px');
+                expect(iframeSrc).not.toContain('rootMarginForLazyLoad=500px%200px');
+            }, 100);
+        });
+        test('should drop an invalid lazyLoadingMargin and log an error', async () => {
+            const loggerErrorSpy = jest.spyOn(logger, 'error').mockImplementation(() => undefined);
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+                lazyLoadingMargin: 'not-a-margin',
+            });
+            await appEmbed.render();
+            await executeAfterWait(() => {
+                const iframeSrc = getIFrameSrc();
+                expect(iframeSrc).toContain('isLazyLoadingForEmbedEnabled=true');
+                expect(iframeSrc).not.toContain('rootMarginForLazyLoad');
+                expect(loggerErrorSpy).toHaveBeenCalledWith('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+            }, 100);
+        });
+        test('should track scrollable ancestors by default when only fullHeight is set', async () => {
+            const scrollContainer = getRootEl();
+            scrollContainer.style.overflow = 'auto';
+            const scrollContainerSpy = jest.spyOn(scrollContainer, 'addEventListener');
+            const resizeObserveSpy = jest.fn();
+            const resizeDisconnectSpy = jest.fn();
+            window.ResizeObserver = jest.fn().mockImplementation(() => ({
+                observe: resizeObserveSpy,
+                disconnect: resizeDisconnectSpy,
+            }));
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+            });
+            await appEmbed.render();
+            await executeAfterWait(() => {
+                expect(scrollContainerSpy).toHaveBeenCalledWith('scroll', expect.any(Function));
+                expect(resizeObserveSpy).toHaveBeenCalledWith(scrollContainer);
+            }, 100);
+            appEmbed.destroy();
+            expect(resizeDisconnectSpy).toHaveBeenCalled();
+            scrollContainer.style.overflow = '';
+            window.ResizeObserver = originalResizeObserver;
+        });
+        test('should skip ancestor tracking when enableScrollableContainerLazyLoading is false', async () => {
+            const scrollContainer = getRootEl();
+            scrollContainer.style.overflow = 'auto';
+            const scrollContainerSpy = jest.spyOn(scrollContainer, 'addEventListener');
+            const windowSpy = jest.spyOn(window, 'addEventListener');
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+                enableScrollableContainerLazyLoading: false,
+            });
+            await appEmbed.render();
+            await executeAfterWait(() => {
+                expect(windowSpy).toHaveBeenCalledWith('scroll', expect.anything(), true);
+                expect(scrollContainerSpy).not.toHaveBeenCalledWith('scroll', expect.any(Function));
+            }, 100);
+            appEmbed.destroy();
+            scrollContainer.style.overflow = '';
+        });
+        test('should wire the window scroll listener to the coordinates sender by default', async () => {
+            const addEventListenerSpy = jest.spyOn(window, 'addEventListener');
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+            });
+            const mockTrigger = jest
+                .spyOn(appEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined));
+            await appEmbed.render();
+            await executeAfterWait(() => {
+                const scrollCall = addEventListenerSpy.mock.calls.find(([eventName, , capture]) => eventName === 'scroll' && capture === true);
+                expect(scrollCall).toBeDefined();
+                // Call the handler the way a real scroll event would.
+                scrollCall[1]();
+                expect(mockTrigger).toHaveBeenCalledWith(HostEvent.VisibleEmbedCoordinates, expect.objectContaining({ top: expect.any(Number) }));
+            }, 100);
+            appEmbed.destroy();
+            addEventListenerSpy.mockRestore();
+        });
+        test('should remove listeners on destroy when the flags come from defaults', async () => {
+            const removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+            });
+            await appEmbed.render();
+            appEmbed.destroy();
+            expect(removeEventListenerSpy).toHaveBeenCalledWith('resize', expect.anything());
+            expect(removeEventListenerSpy).toHaveBeenCalledWith('scroll', expect.anything(), true);
+            removeEventListenerSpy.mockRestore();
+        });
+        test('should keep an explicit false for the lazy loading flags', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+                lazyLoadingForFullHeight: false,
+                enableScrollableContainerLazyLoading: false,
+                lazyLoadingMargin: '0px',
+            });
+            expect(appEmbed.viewConfig.lazyLoadingForFullHeight).toBe(false);
+            expect(appEmbed.viewConfig.enableScrollableContainerLazyLoading).toBe(false);
+            expect(appEmbed.viewConfig.lazyLoadingMargin).toBe('0px');
+        });
         test('should not set lazyLoadingForEmbed when lazyLoadingForFullHeight is enabled but fullHeight is false', async () => {
             const appEmbed = new AppEmbed(getRootEl(), {
                 ...defaultViewConfig,