@thoughtspot/visual-embed-sdk 1.51.0 → 1.51.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thoughtspot/visual-embed-sdk",
-    "version": "1.51.0",
+    "version": "1.51.2",
     "description": "ThoughtSpot Embed SDK",
     "module": "lib/src/index.js",
     "main": "dist/tsembed.js",

package/src/config.ts

@@ -76,3 +76,4 @@ export const URL_MAX_LENGTH = 2000;
  */
 export const DEFAULT_EMBED_WIDTH = '100%';
 export const DEFAULT_EMBED_HEIGHT = '100%';
+export const DEFAULT_LAZY_LOADING_MARGIN = '500px 0px';

package/src/css-variables.ts

@@ -534,6 +534,14 @@ export interface CustomCssVariables {
      */
     '--ts-var-liveboard-header-font-color'?: string;
 
+    /**
+     * Left and right margin of the header and the tab/filter section of an
+     * embedded Liveboard. Use alongside the `liveboardGutter` view config to
+     * keep the header aligned with a custom tile-grid gutter.
+     * @version SDK: 1.53.0 | ThoughtSpot Cloud: 26.10.0.cl
+     */
+    '--ts-var-liveboard-header-horizontal-margin'?: string;
+
     /**
      * Border color of the tiles in the Liveboard.
      */
@@ -554,6 +562,21 @@ export interface CustomCssVariables {
      */
     '--ts-var-liveboard-insight-tile-background'?: string;
 
+    /**
+     * Icon color of the insight tiles in the Liveboard.
+     */
+    '--ts-var-liveboard-insight-tile-icon-color'?: string;
+
+    /**
+     * Font color of the success text in the insight tiles in the Liveboard.
+     */
+    '--ts-var-liveboard-insight-tile-success-color'?: string;
+
+    /**
+     * Font color of the failure text in the insight tiles in the Liveboard.
+     */
+    '--ts-var-liveboard-insight-tile-failure-color'?: string;
+
     /**
      * Border radius of the tiles in the Liveboard.
      */
@@ -812,6 +835,15 @@ export interface CustomCssVariables {
      */
     '--ts-var-parameter-chip-active-text-color'?: string;
 
+    /**
+     * Color of the dot indicator shown on a filter or parameter chip in the
+     * centralized filter modal on a Liveboard. The dot appears when the
+     * filter or parameter value has been modified but the changes are not
+     * yet applied to the Liveboard.
+     * @version SDK: 1.52.0 | ThoughtSpot: 26.10.0.cl
+     */
+    '--ts-var-unsaved-filter-indicator-color'?: string;
+
     /**
      * Background color of the action button in the Liveboard header.
      */

package/src/embed/app.spec.ts

@@ -211,6 +211,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);
@@ -245,6 +246,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);
@@ -388,6 +390,21 @@ describe('App embed tests', () => {
         });
     });
 
+    test('should set isLiveboardAlwaysOn12ColLayout to true in url', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            isLiveboardAlwaysOn12ColLayout: true,
+        } as AppViewConfig);
+
+        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,
@@ -416,6 +433,20 @@ describe('App embed tests', () => {
         });
     });
 
+    test('should set liveboardGutter in url', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardGutter: 8,
+        } as AppViewConfig);
+        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,
@@ -741,6 +772,40 @@ 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 },
+        } as AppViewConfig);
+
+        mockMessageChannel();
+        appEmbed.render();
+
+        const mockPort: any = { 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(), {
@@ -969,11 +1034,48 @@ describe('App embed tests', () => {
         await executeAfterWait(() => {
             expectUrlMatchesWithParams(
                 getIFrameSrc(),
-                `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&enableStarterPrompts=true${defaultParamsPost}#/home`,
+                `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 },
+        } as AppViewConfig);
+        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 },
+        } as AppViewConfig);
+        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 },
+        } as AppViewConfig);
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expect(getIFrameSrc()).not.toContain('openSpotterOnLiveboardByDefault');
+        });
+    });
+
     test('should set spotterFileUploadFileTypes in url', async () => {
         const appEmbed = new AppEmbed(getRootEl(), {
             ...defaultViewConfig,
@@ -2057,6 +2159,238 @@ describe('App embed tests', () => {
             }, 100);
         });
 
+        test('should default lazy loading flags to true when fullHeight is enabled', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+            } as AppViewConfig);
+
+            expect((appEmbed as any).viewConfig.lazyLoadingForFullHeight).toBe(true);
+            expect((appEmbed as any).viewConfig.enableScrollableContainerLazyLoading).toBe(true);
+            expect((appEmbed as any).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,
+            } as AppViewConfig);
+
+            expect((appEmbed as any).viewConfig.lazyLoadingForFullHeight).toBeUndefined();
+            expect(
+                (appEmbed as any).viewConfig.enableScrollableContainerLazyLoading,
+            ).toBeUndefined();
+            expect((appEmbed as any).viewConfig.lazyLoadingMargin).toBeUndefined();
+        });
+
+        test('should not write the defaults back onto the caller view config', async () => {
+            const callerViewConfig = {
+                ...defaultViewConfig,
+                fullHeight: true,
+            } as AppViewConfig;
+
+            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,
+            } as AppViewConfig);
+
+            expect((appEmbed as any).viewConfig.lazyLoadingForFullHeight).toBeUndefined();
+            expect(
+                (appEmbed as any).viewConfig.enableScrollableContainerLazyLoading,
+            ).toBeUndefined();
+            expect((appEmbed as any).viewConfig.lazyLoadingMargin).toBeUndefined();
+        });
+
+        test('should default lazyLoadingMargin when lazyLoadingForFullHeight is set explicitly', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+                lazyLoadingForFullHeight: true,
+            } as AppViewConfig);
+
+            expect((appEmbed as any).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',
+            } as AppViewConfig);
+
+            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',
+            } as AppViewConfig);
+
+            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 as any).ResizeObserver = jest.fn().mockImplementation(() => ({
+                observe: resizeObserveSpy,
+                disconnect: resizeDisconnectSpy,
+            }));
+
+            const appEmbed = new AppEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                fullHeight: true,
+            } as AppViewConfig);
+
+            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 as any).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,
+            } as AppViewConfig);
+
+            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,
+            } as AppViewConfig);
+
+            const mockTrigger = jest
+                .spyOn(appEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined as any));
+
+            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 as any)[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,
+            } as AppViewConfig);
+
+            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',
+            } as AppViewConfig);
+
+            expect((appEmbed as any).viewConfig.lazyLoadingForFullHeight).toBe(false);
+            expect((appEmbed as any).viewConfig.enableScrollableContainerLazyLoading).toBe(false);
+            expect((appEmbed as any).viewConfig.lazyLoadingMargin).toBe('0px');
+        });
+
         test('should not set lazyLoadingForEmbed when lazyLoadingForFullHeight is enabled but fullHeight is false', async () => {
             const appEmbed = new AppEmbed(getRootEl(), {
                 ...defaultViewConfig,

package/src/embed/app.ts

@@ -10,6 +10,7 @@
 
 import { logger } from '../utils/logger';
 import { calculateVisibleElementData, getEffectiveClippingAncestors, getQueryParamString, getScrollableAncestors, isUndefined, isValidCssMargin, setParamIfDefined } from '../utils';
+import { DEFAULT_LAZY_LOADING_MARGIN } from '../config';
 import {
     Param,
     DOMSelector,
@@ -22,8 +23,8 @@ import {
     SpotterFileUploadFileTypes,
 } from '../types';
 import { V1Embed } from './ts-embed';
-import { SpotterChatViewConfig, SpotterSidebarViewConfig, SpotterQueryMode, SpotterShareConversationConfig } from './conversation';
-import { buildSpotterSidebarAppInitData, buildSpotterShareConversationAppInitData } from './spotter-utils';
+import { SpotterChatViewConfig, SpotterSidebarViewConfig, SpotterQueryMode, SpotterShareConversationConfig, StarterPromptsConfig } from './conversation';
+import { buildSpotterSidebarAppInitData, buildSpotterShareConversationAppInitData, buildStarterPromptsAppInitData } from './spotter-utils';
 import { SpotterVizConfig, buildSpotterVizAppInitData } from './spotter-viz-utils';
 
 /**
@@ -67,6 +68,10 @@ export enum Page {
      * Collections listing page
      */
     Collections = 'collections',
+    /**
+     * Liveboard schedules listing page
+     */
+    LiveboardSchedules = 'liveboard-schedules',
 }
 
 /**
@@ -471,6 +476,11 @@ export interface AppViewConfig extends AllEmbedViewConfig {
      * `false` fetches visualizations incrementally as
      * users scroll the page to view the charts and tables.
      *
+     * From SDK 1.52.0, enabling `fullHeight` also turns on
+     * {@link lazyLoadingForFullHeight} and
+     * {@link enableScrollableContainerLazyLoading}, so visualizations load as
+     * they scroll into view. Set either flag to `false` to opt out.
+     *
      * Supported embed types: `AppEmbed`
      * @version SDK: 1.21.0 | ThoughtSpot: 9.4.0.cl, 9.4.0-sw
      * @example
@@ -684,11 +694,17 @@ export interface AppViewConfig extends AllEmbedViewConfig {
     isGranularXLSXCSVSchedulesEnabled?: boolean;
 
     /**
-     * This flag is used to enable the full height lazy load data.
+     * Loads visualizations only as they scroll into the viewport, instead of
+     * loading the whole full-height Liveboard at once.
+     *
+     * From SDK 1.52.0 this is enabled automatically whenever `fullHeight` is
+     * `true`. On SDK 1.51.0 and earlier it defaulted to `false` and had to be
+     * set explicitly. Set it to `false` to load every visualization upfront.
+     * The flag has no effect unless `fullHeight` is enabled.
      *
      * @type {boolean}
      * @version SDK: 1.40.0 | ThoughtSpot: 10.12.0.cl
-     * @default false
+     * @default true when `fullHeight` is enabled, from SDK 1.52.0
      * @example
      * ```js
      * const embed = new AppEmbed('#embed-container', {
@@ -700,28 +716,44 @@ export interface AppViewConfig extends AllEmbedViewConfig {
      */
     lazyLoadingForFullHeight?: boolean;
     /**
-     * This flag is used to enable container-aware full height lazy loading.
+     * Computes the visible region of the embed against its scrollable and
+     * clipping ancestors, instead of treating the browser window as the only
+     * viewport, and tracks scroll and resize on those ancestors.
      *
-     * Use this when the embed is rendered inside a scrollable or clipping
-     * container instead of relying on the browser window as the only viewport.
+     * From SDK 1.52.0 this is enabled automatically whenever `fullHeight` is
+     * `true`. On SDK 1.51.0 and earlier it defaulted to `false` and had to be
+     * set explicitly. Set it to `false` when the page scrolls with the window
+     * and the embed has no clipping ancestor, to skip the extra ancestor
+     * tracking.
      *
      * @type {boolean}
-     * @default false
+     * @default true when `fullHeight` is enabled, from SDK 1.52.0
      * @hidden
      */
     enableScrollableContainerLazyLoading?: boolean;
 
     /**
-     * The margin to be used for lazy loading.
+     * How far outside the viewport a visualization starts loading, when
+     * {@link lazyLoadingForFullHeight} is enabled.
      *
      * For example, if the margin is set to '10px',
      * the visualization will be loaded 10px before its top edge is visible in the
      * viewport.
      *
-     * The format is similar to CSS margin.
+     * The format is similar to CSS margin, so `'500px 0px'` extends the
+     * prefetch 500px above and below the viewport and not sideways. Accepted
+     * units are `px`, `em`, `rem`, `%`, `vh` and `vw`, plus bare `0` and
+     * `auto`; an invalid value is logged and ignored.
+     *
+     * From SDK 1.52.0 this defaults to `'500px 0px'` — roughly one
+     * visualization ahead of the scroll position, so a chart has usually
+     * finished loading by the time it scrolls into view. Use a smaller margin
+     * to cut warehouse queries further, or `'0px'` to load a visualization
+     * only once it is actually visible.
      *
      * @type {string}
      * @version SDK: 1.40.0 | ThoughtSpot: 10.12.0.cl
+     * @default '500px 0px' when `fullHeight` is enabled, from SDK 1.52.0
      * @example
      * ```js
      * const embed = new AppEmbed('#embed-container', {
@@ -897,13 +929,12 @@ export interface AppViewConfig extends AllEmbedViewConfig {
      *        inputChatPlaceholder: 'Ask a question...',
      *        hideStarterPrompts: false,
      *        customStarterPrompts: [{ id: '1', displayText: 'Top products', fullPrompt: 'What are the top products by revenue?' }],
-     *        // loaderHeadline and loaderTips require SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     *        // The options below require SDK: 1.51.0
      *        loaderHeadline: 'Crunching the numbers...',
      *        loaderTips: [
      *            { label: 'Tip', text: 'try asking about revenue by region' },
      *            { label: 'Tip', text: 'use natural language' },
      *        ],
-     *        // liveboardBrandName, spotterBrandName, insightTileBrandName, insightTileViewPlanLabel and insightTileLoaderText require SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
      *        liveboardBrandName: 'Reports',
      *        spotterBrandName: 'Analyst',
      *        insightTileBrandName: 'Insight card',
@@ -1002,6 +1033,7 @@ export interface AppEmbedAppInitData extends DefaultAppInitData {
         spotterSidebarConfig?: SpotterSidebarViewConfig;
         spotterVizConfig?: SpotterVizConfig;
         spotterShareConversationConfig?: SpotterShareConversationConfig;
+        starterPrompts?: StarterPromptsConfig;
     };
 }
 
@@ -1022,6 +1054,16 @@ export class AppEmbed extends V1Embed {
         viewConfig.embedComponentType = 'AppEmbed';
         super(domSelector, viewConfig);
         if (this.viewConfig.fullHeight === true) {
+            if (this.viewConfig.lazyLoadingForFullHeight === undefined) {
+                this.viewConfig.lazyLoadingForFullHeight = true;
+            }
+            if (this.viewConfig.enableScrollableContainerLazyLoading === undefined) {
+                this.viewConfig.enableScrollableContainerLazyLoading = true;
+            }
+            if (this.viewConfig.lazyLoadingMargin === undefined) {
+                this.viewConfig.lazyLoadingMargin = DEFAULT_LAZY_LOADING_MARGIN;
+            }
+
             this.on(EmbedEvent.RouteChange, this.setIframeHeightForNonEmbedLiveboard);
             this.on(EmbedEvent.EmbedHeight, this.updateIFrameHeight);
             this.on(EmbedEvent.EmbedIframeCenter, this.embedIframeCenter);
@@ -1052,7 +1094,8 @@ export class AppEmbed extends V1Embed {
             this.handleError.bind(this),
         );
         const vizInitData = buildSpotterVizAppInitData(sidebarInitData, this.viewConfig);
-        return buildSpotterShareConversationAppInitData(vizInitData, this.viewConfig);
+        const shareInitData = buildSpotterShareConversationAppInitData(vizInitData, this.viewConfig);
+        return buildStarterPromptsAppInitData(shareInitData, this.viewConfig);
     }
 
     /**
@@ -1094,6 +1137,7 @@ export class AppEmbed extends V1Embed {
             enableAskSage,
             collapseSearchBarInitially = false,
             enable2ColumnLayout,
+            isLiveboardAlwaysOn12ColLayout,
             enableCustomColumnGroups = false,
             dataPanelCustomGroupsAccordionInitialState = DataPanelCustomColumnGroupsAccordionState.EXPAND_ALL,
             collapseSearchBar = true,
@@ -1108,6 +1152,7 @@ export class AppEmbed extends V1Embed {
             discoveryExperience,
             coverAndFilterOptionInPDF,
             isLiveboardStylingAndGroupingEnabled,
+            liveboardGutter,
             isPNGInScheduledEmailsEnabled = false,
             isLiveboardXLSXCSVDownloadEnabled,
             isGranularXLSXCSVSchedulesEnabled,
@@ -1190,6 +1235,7 @@ export class AppEmbed extends V1Embed {
                 spotterFileUploadEnabled,
                 spotterFileUploadFileTypes,
                 enableStarterPrompts,
+                openSpotterOnLiveboardByDefault,
             } = spotterChatConfig;
 
             setParamIfDefined(params, Param.HideToolResponseCardBranding, hideToolResponseCardBranding, true);
@@ -1200,6 +1246,9 @@ export class AppEmbed extends V1Embed {
             if (enableStarterPrompts !== undefined) {
                 params[Param.IsStarterPromptsEnabled] = enableStarterPrompts;
             }
+            if (openSpotterOnLiveboardByDefault !== undefined) {
+                params[Param.OpenSpotterOnLiveboardByDefault] = openSpotterOnLiveboardByDefault;
+            }
             if (spotterFileUploadFileTypes !== undefined) {
                 params[Param.SpotterFileUploadFileTypes] = JSON.stringify(spotterFileUploadFileTypes);
             }
@@ -1252,6 +1301,9 @@ export class AppEmbed extends V1Embed {
         if (enable2ColumnLayout !== undefined) {
             params[Param.Enable2ColumnLayout] = enable2ColumnLayout;
         }
+        if (isLiveboardAlwaysOn12ColLayout !== undefined) {
+            params[Param.IsLiveboardAlwaysOn12ColLayout] = isLiveboardAlwaysOn12ColLayout;
+        }
 
         if (enableAskSage) {
             params[Param.enableAskSage] = enableAskSage;
@@ -1271,6 +1323,10 @@ export class AppEmbed extends V1Embed {
             ] = isLiveboardStylingAndGroupingEnabled;
         }
 
+        if (liveboardGutter !== undefined) {
+            params[Param.LiveboardGutter] = liveboardGutter;
+        }
+
         if (isPNGInScheduledEmailsEnabled !== undefined) {
             params[Param.isPNGInScheduledEmailsEnabled] = isPNGInScheduledEmailsEnabled;
         }
@@ -1474,6 +1530,8 @@ export class AppEmbed extends V1Embed {
                 return modularHomeExperience ? 'home/monitor-alerts' : 'insights/monitor-alerts';
             case Page.Collections:
                 return 'collections';
+            case Page.LiveboardSchedules:
+                return 'home/liveboard-schedules';
             case Page.Home:
             default:
                 return 'home';