@thoughtspot/visual-embed-sdk 1.52.1 → 1.52.2-beta.0

package/dist/tsembed.js

@@ -1,4 +1,4 @@
-/* @thoughtspot/visual-embed-sdk version 1.52.1 */
+/* @thoughtspot/visual-embed-sdk version 1.52.2-beta.0 */
 'use client';
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -3772,6 +3772,12 @@
          * ```js
          * const data = await liveboardEmbed.trigger(HostEvent.GetFilters);
          *     console.log('data', data);
+         * // {
+         * //   liveboardFilters: [ ... ],
+         * //   runtimeFilters: [
+         * //     { columnName: "Region", operator: "IN", values: ["West"] }
+         * //   ]
+         * // }
          * ```
          * @example
          * ```js
@@ -3796,9 +3802,9 @@
          *
          * Each filter object must include the following attributes:
          *
-         * `column` - Name of the column to filter on.
+         * `columnName` - Name of the column to filter on.
          *
-         * `oper`  - Filter operator, for example, EQ, IN, CONTAINS.
+         * `operator`  - Filter operator, for example, EQ, IN, CONTAINS.
          *  For information about the supported filter operators,
          *  see link:https://developers.thoughtspot.com/docs/runtime-filters#rtOperator[Developer Documentation].
          *
@@ -3825,8 +3831,8 @@
          *
          * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
          *     filter: {
-         *         column: "item type",
-         *         oper: "IN",
+         *         columnName: "item type",
+         *         operator: "IN",
          *         values: ["bags","shirts"]
          *        }
          *    });
@@ -3836,8 +3842,8 @@
          *
          * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
          *     filter: {
-         *         column: "date",
-         *         oper: "EQ",
+         *         columnName: "date",
+         *         operator: "EQ",
          *         values: ["JULY","2023"],
          *         type: "MONTH_YEAR"
          *        }
@@ -3848,18 +3854,18 @@
          * ```js
          * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
          *  filters: [{
-         *      column: "Item Type",
-         *      oper: 'IN',
+         *      columnName: "Item Type",
+         *      operator: 'IN',
          *      values: ["bags","shirts"]
          *  },
          *    {
-         *      column: "Region",
-         *      oper: 'IN',
+         *      columnName: "Region",
+         *      operator: 'IN',
          *      values: ["West","Midwest"]
          *  },
          *    {
-         *      column: "Date",
-         *      oper: 'EQ',
+         *      columnName: "Date",
+         *      operator: 'EQ',
          *      values: ["2023-07-31"],
          *      type: "EXACT_DATE"
          *    }]
@@ -3873,13 +3879,13 @@
          * ```js
          * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
          *  filters: [{
-         *      column: "(Sample) Retail - Apparel::city",
-         *      oper: 'IN',
+         *      columnName: "(Sample) Retail - Apparel::city",
+         *      operator: 'IN',
          *      values: ["atlanta"]
          *  },
          *  {
-         *      column: "(Sample) Retail - Apparel::Region",
-         *      oper: 'IN',
+         *      columnName: "(Sample) Retail - Apparel::Region",
+         *      operator: 'IN',
          *      values: ["West","Midwest"]
          *  }]
          * });
@@ -3890,8 +3896,8 @@
          * import { ContextType } from '@thoughtspot/visual-embed-sdk';
          * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
          *     filter: {
-         *         column: "item type",
-         *         oper: "IN",
+         *         columnName: "item type",
+         *         operator: "IN",
          *         values: ["shoes", "boots"]
          *     }
          * }, ContextType.Liveboard);
@@ -3901,8 +3907,8 @@
          * // Scope the filter to a specific Liveboard tab
          * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
          *     filter: {
-         *         column: "item type",
-         *         oper: "IN",
+         *         columnName: "item type",
+         *         operator: "IN",
          *         values: ["bags", "shirts"],
          *         applicability: {
          *             level: "TAB",
@@ -3911,6 +3917,12 @@
          *     }
          * });
          * ```
+         * Use `columnName` and `operator` - the same spelling as
+         * {@link RuntimeFilter}. The older `column` and `oper` spellings are
+         * deprecated; they are still accepted, but pass only one spelling of each
+         * field, never both. To reapply the filter state captured from
+         * {@link EmbedEvent.FilterChanged}, use `convertFilterChangedToUpdateFiltersPayload`
+         * to convert its payload into the shape expected here.
          * @version SDK: 1.23.0 | ThoughtSpot: 9.4.0.cl
          */
         HostEvent["UpdateFilters"] = "updateFilters";
@@ -4896,7 +4908,6 @@
         Param["IsStarterPromptsEnabled"] = "enableStarterPrompts";
         Param["UpdatedSpotterExperience"] = "updatedSpotterExperience";
         Param["SpotterDataSources"] = "spotterDataSources";
-        Param["AnalystId"] = "analystId";
         Param["OpenSpotterOnLiveboardByDefault"] = "openSpotterOnLiveboardByDefault";
         Param["ShowAnswerEditPanel"] = "showAnswerEditPanel";
     })(Param || (Param = {}));
@@ -7122,6 +7133,18 @@
          * ```
          */
         Action["DeleteCollection"] = "deleteCollection";
+        /**
+         * Controls the visibility of the "Customize homepage" button on the
+         * embedded home page.
+         * @version SDK: 1.55.0 | ThoughtSpot Cloud: 26.12.0.cl
+         * @example
+         * ```js
+         * {
+         *     hiddenActions: [Action.CustomizeHomepage],
+         * }
+         * ```
+         */
+        Action["CustomizeHomepage"] = "customizeHomepage";
     })(exports.Action || (exports.Action = {}));
     exports.PrefetchFeatures = void 0;
     (function (PrefetchFeatures) {
@@ -7626,7 +7649,7 @@
         TableContentDensity["Compact"] = "COMPACT";
     })(exports.TableContentDensity || (exports.TableContentDensity = {}));
 
-    var version$1="1.52.1";var pkg = {version:version$1};
+    var version$1="1.52.2-beta.0";var pkg = {version:version$1};
 
     const { version } = pkg;
 
@@ -7799,7 +7822,7 @@
         SSR_ENVIRONMENT_ERROR: 'SSR environment detected. This function cannot be called in SSR environment.',
         UPDATE_PARAMS_FAILED: 'Failed to update embed parameters',
         INVALID_SPOTTER_DOCUMENTATION_URL: 'Invalid spotterDocumentationUrl. Please provide a valid http or https URL.',
-        UPDATEFILTERS_INVALID_PAYLOAD: 'UpdateFilters requires a valid filter or filters array. Expected: { filter: { column, oper, values } } or { filters: [{ column, oper, values }, ...] }',
+        UPDATEFILTERS_INVALID_PAYLOAD: 'UpdateFilters requires a valid filter or filters array. Expected: { filter: { columnName, operator, values } } or { filters: [{ columnName, operator, values }, ...] }',
         DRILLDOWN_INVALID_PAYLOAD: 'DrillDown requires a valid points object. Expected: { points: { clickedPoint?, selectedPoints? }, autoDrillDown?, vizId? }',
         UPDATEPARAMETERS_INVALID_PAYLOAD: 'UpdateParameters received an invalid applicability. Expected: { level: LIVEBOARD | TAB | GROUP, targetId } where targetId is required for TAB and GROUP levels',
     };
@@ -21671,7 +21694,8 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
     const isValidApplicability = (a) => {
         if (isUndefined_1(a))
             return true;
-        // targetId is not required at LIVEBOARD level, since the filter applies to the whole Liveboard
+        // targetId is not required at LIVEBOARD level, since the filter applies to
+        // the whole Liveboard
         return isPlainObject_1(a)
             && Object.values(exports.ApplicabilityLevel).includes(a.level)
             && (a.level === exports.ApplicabilityLevel.Liveboard || (isString_1(a.targetId) && a.targetId.trim().length > 0));
@@ -21690,8 +21714,52 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
         const hasValidFilters = Array.isArray(payload.filters) && payload.filters.length > 0 && payload.filters.every(isValidFilter);
         return !!(hasValidFilter || hasValidFilters);
     }
+    /**
+     * Rewrites one filter's `columnName`/`operator` to `column`/`oper`.
+     *
+     * Callers may use either spelling: `columnName`/`operator` match
+     * {@link RuntimeFilter} and the `EmbedEvent.FilterChanged` payload, so a
+     * converted payload can be replayed as-is. But the payload is forwarded to the
+     * embedded app unchanged, and only `column`/`oper` are known to be understood
+     * there - so the alias must be swapped here, or it would pass validation and
+     * then be silently ignored.
+     *
+     * If a caller supplies both spellings of a field - which TypeScript rejects,
+     * but JavaScript callers can still do - the documented `columnName`/`operator`
+     * wins. Deferring to the deprecated spelling would quietly discard the value
+     * the rest of the SDK tells people to use.
+     * @param filter One entry from the UpdateFilters payload.
+     */
+    function resolveFilterAliases(filter) {
+        var _a, _b;
+        if (!isPlainObject_1(filter))
+            return filter;
+        const column = (_a = filter.columnName) !== null && _a !== void 0 ? _a : filter.column;
+        const oper = (_b = filter.operator) !== null && _b !== void 0 ? _b : filter.oper;
+        const { columnName, operator, ...rest } = filter;
+        return {
+            ...rest,
+            ...(isUndefined_1(column) ? {} : { column }),
+            ...(isUndefined_1(oper) ? {} : { oper }),
+        };
+    }
+    /**
+     * Rewrites every filter in an UpdateFilters payload to use `column`/`oper`,
+     * whichever spelling the caller supplied. Call after validation.
+     * @param payload The UpdateFilters host event payload.
+     */
+    function resolveUpdateFiltersAliases(payload) {
+        if (!isPlainObject_1(payload))
+            return payload;
+        return {
+            ...payload,
+            ...(payload.filter ? { filter: resolveFilterAliases(payload.filter) } : {}),
+            ...(Array.isArray(payload.filters) ? { filters: payload.filters.map(resolveFilterAliases) } : {}),
+        };
+    }
     function isValidUpdateParametersPayload(payload) {
-        // Only validates the applicability of each parameter (null treated as absent); the rest is forwarded as-is for backward compatibility.
+        // Only validates the applicability of each parameter (null treated as
+        // absent); the rest is forwarded as-is for backward compatibility.
         if (!Array.isArray(payload))
             return true;
         return payload.every((p) => {
@@ -21739,7 +21807,8 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
     /**
      * Maps HostEvent to its corresponding UIPassthroughEvent.
      * Includes both custom-handler events (Pin, SaveAnswer, UpdateFilters, DrillDown)
-     * and getter events (GetAnswerSession, GetFilters, etc.) that use getDataWithPassthroughFallback.
+     * and getter events (GetAnswerSession, GetFilters, etc.) that use
+     * getDataWithPassthroughFallback.
      */
     const PASSTHROUGH_MAP = {
         // Custom handlers (setters with special logic)
@@ -21890,17 +21959,21 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                 throwUpdateFiltersValidationError();
             }
             // The shared contract accepts both current (columnName/operator) and
-            // legacy (column/oper) filter field names — as does the validation
-            // above and the app at runtime. The UIPassthrough FilterUpdate type
-            // still requires the legacy names; bridge until that contract is
-            // audited.
-            return this.handleHostEventWithParam(exports.UIPassthroughEvent.UpdateFilters, payload, context);
+            // legacy (column/oper) filter field names, but only the legacy pair is
+            // understood downstream, so the payload is rewritten before it is
+            // forwarded — otherwise a columnName/operator filter passes validation
+            // here and is then silently ignored by the app. The cast bridges the
+            // UIPassthrough FilterUpdate type, which still declares only the legacy
+            // names.
+            const resolvedPayload = resolveUpdateFiltersAliases(payload);
+            return this.handleHostEventWithParam(exports.UIPassthroughEvent.UpdateFilters, resolvedPayload, context);
         }
         handleUpdateParametersEvent(payload, context) {
             if (!isValidUpdateParametersPayload(payload)) {
                 throwUpdateParametersValidationError();
             }
-            // UpdateParameters has no UI passthrough contract; dispatch over the legacy channel
+            // UpdateParameters has no UI passthrough contract; dispatch over the
+            // legacy channel
             return this.hostEventFallback(exports.HostEvent.UpdateParameters, payload, context);
         }
         handleDrillDownEvent(payload, context) {
@@ -21911,8 +21984,8 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
         }
         /**
          * Dispatches a host event using the appropriate channel:
-         * 1. If the embedded app supports UI passthrough for this event, use it (custom handler or getter).
-         * 2. Otherwise fall back to the legacy host event channel.
+         * 1. If the embedded app supports UI passthrough for this event, use it (custom
+         * handler or getter). 2. Otherwise fall back to the legacy host event channel.
          *
          * @param hostEvent - The host event to trigger
          * @param payload - Optional payload for the event
@@ -21921,7 +21994,8 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
         async triggerHostEvent(hostEvent, payload, context) {
             const customHandler = this.customHandlers[hostEvent];
             const passthroughEvent = PASSTHROUGH_MAP[hostEvent];
-            // If embedded app supports passthrough but not this event, use legacy channel
+            // If embedded app supports passthrough but not this event, use legacy
+            // channel
             const keys = passthroughEvent ? await this.getAvailableUIPassthroughKeys(context) : [];
             if (passthroughEvent && keys.length > 0 && !keys.includes(passthroughEvent)) {
                 return this.hostEventFallback(hostEvent, payload, context);
@@ -22128,11 +22202,15 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
      */
     const PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY = 'tsEmbedOriginalPosition';
     const PRERENDER_WRAPPER_ID_PREFIX = 'tsEmbed-pre-render-wrapper-';
+    const PRERENDER_PARKED_TRANSFORM = 'translateY(-100%)';
+    /** The height createPreRenderWrapper() seeds before anything is measured. */
+    const UNMEASURED_WRAPPER_HEIGHT = '100vh';
     // The container applies UpdateEmbedParams through React state, so a delivered
     // post is not the same as the params being in effect.
     const UPDATE_EMBED_PARAMS_SETTLE_MS = 200;
-    // The container ignores runtimeFilterParams/runtimeParameterParams unless truthy, so
-    // null or '' leaves the previous embed's values in place. '&' is truthy and parses to {}.
+    // The container ignores runtimeFilterParams/runtimeParameterParams unless
+    // truthy, so null or '' leaves the previous embed's values in place. '&' is
+    // truthy and parses to {}.
     const NO_RUNTIME_PARAMS = '&';
     /**
      * The event id map from v2 event names to v1 event id
@@ -22171,7 +22249,6 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
             this.shouldEncodeUrlQueryParams = false;
             this.defaultHiddenActions = [exports.Action.ReportError];
             this.preRenderContainerEl = document.body;
-            this.containerScrollListener = null;
             /**
              * Handler for fullscreen change events
              */
@@ -22330,7 +22407,8 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                     const AUTH_INIT_FALLBACK_DELAY = 1000;
                     // Wait for 1 second to ensure the embed container is loaded
                     // This is a workaround to ensure the embed container is loaded
-                    // this is needed until all clusters have EmbedListenerReady event
+                    // this is needed until all clusters have EmbedListenerReady
+                    // event
                     setTimeout(processEmbedContainerReady, AUTH_INIT_FALLBACK_DELAY);
                 }
                 else if (source === exports.EmbedEvent.EmbedListenerReady) {
@@ -22338,7 +22416,8 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                 }
             };
             // Subclasses that navigate the pre-render on show must await this before
-            // triggering Navigate. Resolves even on failure, so navigation is never blocked.
+            // triggering Navigate. Resolves even on failure, so navigation is never
+            // blocked.
             this.preRenderParamsApplied = Promise.resolve();
             this.hostElement = getDOMNode(domSelector);
             this.eventHandlerMap = new Map();
@@ -22668,8 +22747,9 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                 ...this.viewConfig,
                 ...queryParams,
                 ...appInitData,
-                // A show cycle has no URL to carry these, so the payload always states them
-                // — including "none", which is the case that leaks the previous filters.
+                // A show cycle has no URL to carry these, so the payload always
+                // states them — including "none", which is the case that leaks the
+                // previous filters.
                 runtimeFilterParams: getFilterQuery((_a = this.viewConfig.runtimeFilters) !== null && _a !== void 0 ? _a : []) || NO_RUNTIME_PARAMS,
                 runtimeParameterParams: getRuntimeParameters((_b = this.viewConfig.runtimeParameters) !== null && _b !== void 0 ? _b : [])
                     || NO_RUNTIME_PARAMS,
@@ -23014,7 +23094,7 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                 top: '0',
                 left: '0',
                 width: '100vw',
-                height: '100vh',
+                height: UNMEASURED_WRAPPER_HEIGHT,
             };
             setStyleProperties(preRenderWrapper, initialPreRenderWrapperStyle);
             return preRenderWrapper;
@@ -23082,10 +23162,26 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
             return placeholder;
         }
         /**
-         * Resolves the configured preRenderContainer to a live element, falling
-         * back to `document.body`. A string selector is re-queried on every call so
-         * a remounted container (E.g.: React replacing the node) resolves to the
-         * fresh element; an element passed directly cannot be re-resolved.
+         * Resolves the configured preRenderContainer to a live element. A string
+         * selector is re-queried on every call so a remounted container (E.g.: React
+         * replacing the node) resolves to the fresh element; an element passed
+         * directly cannot be re-resolved.
+         *
+         * With nothing configured the frame goes into the host element's nearest
+         * scrolling ancestor, falling back to `document.body`.
+         *
+         * The wrapper is absolutely positioned, so it follows the page for free —
+         * but only while it sits inside whatever scrolls. `document.body` is right
+         * only when the document itself is the scroller; an app that scrolls an
+         * inner element instead left the frame pinned to the viewport while the page
+         * moved under it (SCAL-338563). Being inside the scroller also lets wheel
+         * events chain out of the frame into it, which they cannot do from
+         * `document.body`.
+         *
+         * A scrolling ancestor is layout chrome rather than route content, so it
+         * outlives the embed in practice; and if it does go, the host element goes
+         * with it and this instance is remounting anyway.
+         * `reconcilePreRenderContainer` re-runs this on a detached container.
          */
         resolvePreRenderContainerTarget() {
             var _a;
@@ -23105,7 +23201,13 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
             else if (containerConfig) {
                 container = containerConfig;
             }
-            return (_a = container) !== null && _a !== void 0 ? _a : document.body;
+            if (container) {
+                return container;
+            }
+            if (!this.hostElement) {
+                return document.body;
+            }
+            return (_a = getScrollableAncestors(this.hostElement)[0]) !== null && _a !== void 0 ? _a : document.body;
         }
         inheritPreRenderContainer() {
             var _a;
@@ -23150,8 +23252,9 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
          * Re-attaches the wrapper to a live container when the previously resolved
          * one has been detached or no longer holds the wrapper — e.g. the host app
          * remounted a custom preRenderContainer, which would otherwise leave a stale
-         * reference and collapse the wrapper. Only string selectors can be
-         * re-resolved; a container passed as an element is left untouched.
+         * reference and collapse the wrapper. Selectors and the auto-resolved
+         * scrolling ancestor are both re-resolved; a container passed as an element
+         * is left untouched, as there is nothing to re-query.
          */
         reconcilePreRenderContainer() {
             const wrapper = this.preRenderWrapper;
@@ -23170,14 +23273,6 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
             if (resolved === stored && stored.contains(wrapper)) {
                 return;
             }
-            if (this.containerScrollListener && stored !== resolved) {
-                if (stored !== document.body) {
-                    stored.removeEventListener('scroll', this.containerScrollListener);
-                }
-                if (resolved !== document.body) {
-                    resolved.addEventListener('scroll', this.containerScrollListener);
-                }
-            }
             this.preRenderContainerEl = resolved;
             this.applyPreRenderContainerPositioning();
             if (wrapper.parentNode !== resolved) {
@@ -23239,11 +23334,12 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
          */
         setIFrameHeight(height) {
             if (this.isPreRendered) {
+                const next = getCssDimension(height);
                 if (this.insertedDomEl) {
-                    this.insertedDomEl.style.height = getCssDimension(height);
+                    this.insertedDomEl.style.height = next;
                 }
                 else if (this.preRenderWrapper) {
-                    this.preRenderWrapper.style.height = getCssDimension(height);
+                    this.preRenderWrapper.style.height = next;
                 }
             }
             else {
@@ -23396,8 +23492,9 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                 return;
             this.preRenderWrapper[this.embedNodeKey] = this;
         }
-        // The flag lives on the wrapper because it describes the iframe: an instance
-        // hidden when the container announced itself would otherwise report false forever.
+        // The flag lives on the wrapper because it describes the iframe: an
+        // instance hidden when the container announced itself would otherwise
+        // report false forever.
         markEmbedContainerLoaded() {
             this.isEmbedContainerLoaded = true;
             if (this.preRenderWrapper) {
@@ -23677,34 +23774,47 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
             delete container.dataset[PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY];
         }
         /**
-         * Detaches and clears the container scroll listener, if one is attached.
-         */
-        removeContainerScrollListener() {
-            if (!this.containerScrollListener) {
+         * Re-sizes the wrapper when its placeholder changes size.
+         *
+         * Position deliberately has no equivalent. An absolutely positioned wrapper
+         * follows its containing block for free, so a correctly placed frame is the
+         * browser's job and costs nothing; repositioning it on scroll would mean a
+         * layout read and a style write per frame to compensate for placing it in
+         * the wrong box. Size is the one thing the browser will not do for us: the
+         * placeholder grows when the embedded app reports a new height, and the
+         * wrapper has to be told.
+         */
+        observePreRenderSize() {
+            var _a;
+            if (this.getPreRenderConfig().doNotTrackSize || typeof ResizeObserver === 'undefined') {
+                return;
+            }
+            const placeholder = this.getPreRenderPlaceHolderElement();
+            if (!placeholder) {
                 return;
             }
-            const customContainer = this.getCustomPreRenderContainer();
-            customContainer === null || customContainer === void 0 ? void 0 : customContainer.removeEventListener('scroll', this.containerScrollListener);
-            this.containerScrollListener = null;
+            (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+            this.resizeObserver = new ResizeObserver(() => this.syncPreRenderStyle());
+            this.resizeObserver.observe(placeholder);
         }
         /**
          * Destroys the ThoughtSpot embed, and remove any nodes from the DOM.
          * @version SDK: 1.19.1 | ThoughtSpot: *
          */
         destroy() {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             try {
                 this.removeFullscreenChangeHandler();
-                this.removeContainerScrollListener();
+                (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
                 this.unsubscribeToEvents();
-                (_a = this.preRenderWrapper) === null || _a === void 0 ? void 0 : _a.remove();
+                (_b = this.preRenderWrapper) === null || _b === void 0 ? void 0 : _b.remove();
                 this.restorePreRenderContainerPosition();
                 if (!this.isRendered) {
                     return;
                 }
                 if (!getEmbedConfig().waitForCleanupOnDestroy) {
                     this.trigger(exports.HostEvent.DestroyEmbed);
-                    (_c = (_b = this.insertedDomEl) === null || _b === void 0 ? void 0 : _b.parentNode) === null || _c === void 0 ? void 0 : _c.removeChild(this.insertedDomEl);
+                    (_d = (_c = this.insertedDomEl) === null || _c === void 0 ? void 0 : _c.parentNode) === null || _d === void 0 ? void 0 : _d.removeChild(this.insertedDomEl);
                 }
                 else {
                     const cleanupTimeout = getEmbedConfig().cleanupTimeout;
@@ -23785,7 +23895,7 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
          * wrapper to overlay it.
          */
         async showPreRender() {
-            var _a, _b;
+            var _a;
             uploadMixpanelEvent(MIXPANEL_EVENT.VISUAL_SDK_SHOW_PRE_RENDER, {
                 preRenderId: this.getPreRenderConfig().id,
                 embedComponentType: this.viewConfig.embedComponentType,
@@ -23804,54 +23914,49 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
             this.beforePrerenderVisible();
             if (this.hostElement) {
                 this.insertedDomEl = this.createPreRenderPlaceholder();
-                if (this.viewConfig.fullHeight) {
-                    // If fullHeight has already sized the wrapper, seed the placeholder
-                    // with the same height so syncPreRenderStyle gets an accurate rect.
-                    const existingHeight = this.preRenderWrapper.style.height;
-                    if (existingHeight) {
-                        this.insertedDomEl.style.height = existingHeight;
-                    }
+                // Carry a height fullHeight has already measured onto the fresh
+                // placeholder, so a re-show does not flash at frameParams height.
+                // UNMEASURED_WRAPPER_HEIGHT is what createPreRenderWrapper() seeds
+                // before anything has been measured; treating that as a measurement
+                // is what made a first reveal overshoot to a full viewport.
+                const wrapperHeight = this.preRenderWrapper.style.height;
+                if (this.viewConfig.fullHeight
+                    && wrapperHeight
+                    && wrapperHeight !== UNMEASURED_WRAPPER_HEIGHT) {
+                    this.insertedDomEl.style.height = wrapperHeight;
                 }
                 const placeHolderId = this.getPreRenderIds().placeHolder;
                 // Remove any stale placeholder from a previous cycle. It is located
-                // via a subtree-wide querySelector, so it may be nested deeper than a
-                // direct child (E.g.: with fullHeight the host app can wrap it). Use
-                // Element.remove() — which detaches from whatever the real parent is —
-                // rather than hostElement.removeChild(), which throws NotFoundError
-                // when the match is not a direct child. Mirrors the wrapper/child
-                // cleanup in createPreRenderWrapper()/createPreRenderChild().
+                // via a subtree-wide querySelector, so it may be nested deeper
+                // than a direct child (E.g.: with fullHeight the host app can wrap
+                // it). Use Element.remove() — which detaches from whatever the real
+                // parent is — rather than hostElement.removeChild(), which throws
+                // NotFoundError when the match is not a direct child. Mirrors the
+                // wrapper/child cleanup in
+                // createPreRenderWrapper()/createPreRenderChild().
                 (_a = this.hostElement.querySelector(`#${placeHolderId}`)) === null || _a === void 0 ? void 0 : _a.remove();
                 this.hostElement.appendChild(this.insertedDomEl);
                 this.syncPreRenderStyle();
-                const customContainer = this.getCustomPreRenderContainer();
-                if (customContainer && !this.containerScrollListener) {
-                    this.containerScrollListener = () => this.syncPreRenderStyle();
-                    customContainer.addEventListener('scroll', this.containerScrollListener);
-                }
-                if (!this.getPreRenderConfig().doNotTrackSize) {
-                    const observeTarget = (_b = this.insertedDomEl) !== null && _b !== void 0 ? _b : this.hostElement;
-                    this.resizeObserver = new ResizeObserver((entries) => {
-                        entries.forEach((entry) => {
-                            if (entry.target === observeTarget) {
-                                this.syncPreRenderStyle();
-                            }
-                        });
-                    });
-                    this.resizeObserver.observe(observeTarget);
-                }
+                this.observePreRenderSize();
             }
             removeStyleProperties(this.preRenderWrapper, [
                 'z-index',
                 'opacity',
-                'pointer-events',
                 'overflow',
+                'transform',
             ]);
+            // Set rather than removed: a container that carries `pointer-events:
+            // none` — the usual styling for a parking root that must not swallow
+            // clicks — passes it down, and dropping the property here would leave
+            // the inherited `none` in force and the frame dead to input.
+            setStyleProperties(this.preRenderWrapper, { pointerEvents: 'auto' });
             this.subscribeToEvents();
             // Setup fullscreen change handler for prerendered components
             if (this.iFrame) {
                 this.setupFullscreenChangeHandler();
             }
-            // Last, so everything above still sees the instance being taken over from.
+            // Last, so everything above still sees the instance being taken over
+            // from.
             this.takeOverPreRender();
             return this;
         }
@@ -23897,6 +24002,7 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
          * If the component is not preRendered, it issues a warning.
          */
         hidePreRender() {
+            var _a;
             uploadMixpanelEvent(MIXPANEL_EVENT.VISUAL_SDK_HIDE_PRE_RENDER, {
                 preRenderId: this.getPreRenderConfig().id,
                 embedComponentType: this.viewConfig.embedComponentType,
@@ -23916,12 +24022,15 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                 top: '0',
                 left: '0',
                 overflow: 'hidden',
+                // Keeps the measured size — so the next show needs no resize, which
+                // is the point of pre-rendering — while lifting the box out of
+                // the container's scrollable area. Overflow only extends
+                // downwards, so a hidden frame parked above the top edge adds
+                // none, where one left at full height shows as blank scroll space.
+                transform: PRERENDER_PARKED_TRANSFORM,
             };
             setStyleProperties(this.preRenderWrapper, preRenderHideStyles);
-            this.removeContainerScrollListener();
-            if (this.resizeObserver) {
-                this.resizeObserver.disconnect();
-            }
+            (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
             const placeHolderEle = this.getPreRenderPlaceHolderElement();
             if (placeHolderEle) {
                 placeHolderEle.parentElement.removeChild(placeHolderEle);
@@ -24138,6 +24247,18 @@ mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies:
                 starterPrompts,
             },
         };
+    }
+    function buildSpotterAnalystAppInitData(initData, viewConfig) {
+        const { spotterAnalystConfig } = viewConfig;
+        if (!(spotterAnalystConfig === null || spotterAnalystConfig === void 0 ? void 0 : spotterAnalystConfig.analystId))
+            return initData;
+        return {
+            ...initData,
+            embedParams: {
+                ...(initData.embedParams || {}),
+                spotterAnalystConfig,
+            },
+        };
     }
 
     function buildSpotterVizAppInitData(initData, viewConfig) {
@@ -24731,8 +24852,9 @@ query GetEurekaVizSnapshots(
      * @summary Liveboard & visualization embed
      * @author Ayon Ghosh <ayon.ghosh@thoughtspot.com>
      */
-    // Home unmounts the liveboard container, which is how its state gets cleared. The
-    // settle window gives the container time to do it before we ask for the liveboard back.
+    // Home unmounts the liveboard container, which is how its state gets cleared.
+    // The settle window gives the container time to do it before we ask for the
+    // liveboard back.
     const HOME_ROUTE = 'home';
     const HOME_SETTLE_MS = 200;
     /**
@@ -25030,21 +25152,24 @@ query GetEurekaVizSnapshots(
         }
         beforePrerenderVisible() {
             super.beforePrerenderVisible();
-            // Captured before showPreRender() hands the wrapper over to this instance.
-            // Itself means a hide/show, not a hand-over, so there is nothing stale to clear.
+            // Captured before showPreRender() hands the wrapper over to this
+            // instance. Itself means a hide/show, not a hand-over, so there is
+            // nothing stale to clear.
             const previous = this.getPreRenderObj();
             const showing = previous === this ? undefined : previous === null || previous === void 0 ? void 0 : previous.currentLiveboardState;
             this.executeAfterEmbedContainerLoaded(async () => {
-                // Without this the params callback suspends on its await and Navigate
-                // goes out first, so the container loads with the previous config's filters.
+                // Without this the params callback suspends on its await and
+                // Navigate goes out first, so the container loads with the previous
+                // config's filters.
                 await this.preRenderParamsApplied;
                 if (this.isShowingLiveboardRoute(showing)) {
-                    // Navigate to the route we are already on is a no-op, so the liveboard
-                    // keeps its state. Home unmounts the container, which clears it.
+                    // Navigate to the route we are already on is a no-op, so the
+                    // liveboard keeps its state. Home unmounts the container, which
+                    // clears it.
                     this.trigger(exports.HostEvent.Navigate, HOME_ROUTE)
                         .catch((error) => logger$3.warn('Could not route via home', error));
-                    // Not awaited above: the container never acks Navigate, so that promise
-                    // only settles on the 30s trigger timeout.
+                    // Not awaited above: the container never acks Navigate, so
+                    // that promise only settles on the 30s trigger timeout.
                     await new Promise((resolve) => {
                         setTimeout(resolve, HOME_SETTLE_MS);
                     });
@@ -25058,8 +25183,9 @@ query GetEurekaVizSnapshots(
                 };
             });
         }
-        // The whole route, not just the liveboard id: the path is built from the viz, tab
-        // and view too, so a same-liveboard show onto another tab is a real navigation.
+        // The whole route, not just the liveboard id: the path is built from the
+        // viz, tab and view too, so a same-liveboard show onto another tab is a
+        // real navigation.
         isShowingLiveboardRoute(showing) {
             if (!(showing === null || showing === void 0 ? void 0 : showing.liveboardId))
                 return false;
@@ -26009,10 +26135,11 @@ query SendMessage($params: Input_convassist_SendMessageRequest) {
             const defaultAppInitData = await super.getAppInitData();
             const sidebarInitData = buildSpotterSidebarAppInitData(defaultAppInitData, this.viewConfig, this.handleError.bind(this));
             const shareInitData = buildSpotterShareConversationAppInitData(sidebarInitData, this.viewConfig);
-            return buildStarterPromptsAppInitData(shareInitData, this.viewConfig);
+            const starterPromptsInitData = buildStarterPromptsAppInitData(shareInitData, this.viewConfig);
+            return buildSpotterAnalystAppInitData(starterPromptsInitData, this.viewConfig);
         }
         getEmbedParamsObject() {
-            const { searchOptions, disableSourceSelection, hideSourceSelection, dataPanelV2, updatedSpotterExperience, showSpotterLimitations, hideSampleQuestions, runtimeFilters, excludeRuntimeFiltersfromURL, runtimeParameters, excludeRuntimeParametersfromURL, updatedSpotterChatPrompt, showSpotterRadiance, defaultQueryMode, enableStopAnswerGenerationEmbed, spotterChatConfig, spotterAnalystConfig, } = this.viewConfig;
+            const { searchOptions, disableSourceSelection, hideSourceSelection, dataPanelV2, updatedSpotterExperience, showSpotterLimitations, hideSampleQuestions, runtimeFilters, excludeRuntimeFiltersfromURL, runtimeParameters, excludeRuntimeParametersfromURL, updatedSpotterChatPrompt, showSpotterRadiance, defaultQueryMode, enableStopAnswerGenerationEmbed, spotterChatConfig, } = this.viewConfig;
             const queryParams = this.getBaseQueryParams();
             queryParams[Param.SpotterEnabled] = true;
             // Boolean params
@@ -26025,7 +26152,6 @@ query SendMessage($params: Input_convassist_SendMessageRequest) {
             setParamIfDefined(queryParams, Param.ShowSpotterRadiance, showSpotterRadiance, true);
             setParamIfDefined(queryParams, Param.DefaultQueryMode, defaultQueryMode);
             setParamIfDefined(queryParams, Param.EnableStopAnswerGenerationEmbed, enableStopAnswerGenerationEmbed, true);
-            setParamIfDefined(queryParams, Param.AnalystId, spotterAnalystConfig === null || spotterAnalystConfig === void 0 ? void 0 : spotterAnalystConfig.analystId);
             // Handle spotterChatConfig params
             if (spotterChatConfig) {
                 const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, enableStarterPrompts, } = spotterChatConfig;
@@ -26632,6 +26758,213 @@ query GetEurekaResults($params: Input_eureka_SearchRequest) {
         return result;
     };
 
+    /**
+     * Copyright (c) 2026
+     *
+     * Utility to convert the payload emitted by `EmbedEvent.FilterChanged`
+     * into the payload shape expected by `HostEvent.UpdateFilters`, so that
+     * the current filter state of a Liveboard can be captured and re-applied
+     * later without having to hand-parse the event payload.
+     * @summary Filter payload converter
+     */
+    /**
+     * Coerces an epoch/count field to a number, returning `null` when the value is
+     * absent or not a finite number. The payload arrives as JSON from the iframe,
+     * so a missing field can be `null` as well as `undefined`, and `Number(null)`
+     * or `Number('')` would otherwise silently become a valid-looking `0`
+     * (i.e. the Unix epoch, or a zero-length period).
+     * @param value Raw value from the date filter payload.
+     */
+    function toFiniteNumber(value) {
+        if (isNil_1(value) || value === '')
+            return null;
+        const numericValue = Number(value);
+        return Number.isFinite(numericValue) ? numericValue : null;
+    }
+    const DATE_FILTER_VALUE_EXTRACTORS = {
+        EXACT_DATE: (dateFilter) => {
+            const epoch = toFiniteNumber(dateFilter.epoch);
+            return epoch === null ? [] : [epoch];
+        },
+        EXACT_DATE_RANGE: (dateFilter) => {
+            var _a;
+            const { lowEpoch, highEpoch } = (_a = dateFilter.dateRange) !== null && _a !== void 0 ? _a : {};
+            const low = toFiniteNumber(lowEpoch);
+            const high = toFiniteNumber(highEpoch);
+            return low === null || high === null ? [] : [low, high];
+        },
+        MONTH_YEAR: (dateFilter) => (dateFilter.monthName && dateFilter.yearName
+            ? [dateFilter.monthName, dateFilter.yearName]
+            : []),
+        QUARTER_YEAR: (dateFilter) => (dateFilter.quarterName && dateFilter.yearName
+            ? [dateFilter.quarterName, dateFilter.yearName]
+            : []),
+        YEAR_ONLY: (dateFilter) => (dateFilter.yearName ? [dateFilter.yearName] : []),
+        LAST_N_PERIOD: (dateFilter) => {
+            const count = toFiniteNumber(dateFilter.number);
+            return count === null ? [] : [count];
+        },
+        NEXT_N_PERIOD: (dateFilter) => {
+            const count = toFiniteNumber(dateFilter.number);
+            return count === null ? [] : [count];
+        },
+    };
+    // Date filter types with no `values` (e.g. TODAY needs no operand).
+    const PERIOD_ONLY_DATE_FILTER_TYPES = new Set([
+        'THIS_PERIOD', 'PERIOD_TO_DATE', 'TODAY', 'YESTERDAY', 'TOMORROW',
+    ]);
+    function convertDateFilterToParam(columnName, dateFilterContent) {
+        var _a;
+        const dateFilter = dateFilterContent === null || dateFilterContent === void 0 ? void 0 : dateFilterContent.dateFilter;
+        if (!(dateFilter === null || dateFilter === void 0 ? void 0 : dateFilter.type))
+            return null;
+        let values;
+        const getValues = DATE_FILTER_VALUE_EXTRACTORS[dateFilter.type];
+        if (getValues) {
+            values = getValues(dateFilter);
+            // Required fields (e.g. epoch, yearName) are missing - the source data
+            // can't be reconstructed faithfully, so skip rather than emit a filter
+            // that would clear/corrupt this column when re-applied.
+            if (values.length === 0)
+                return null;
+        }
+        else if (PERIOD_ONLY_DATE_FILTER_TYPES.has(dateFilter.type)) {
+            values = [];
+        }
+        else {
+            // Unrecognized date filter type - skip rather than guess.
+            return null;
+        }
+        const param = {
+            columnName,
+            operator: (_a = dateFilter.op) !== null && _a !== void 0 ? _a : exports.RuntimeFilterOp.EQ,
+            values,
+            type: dateFilter.type,
+        };
+        if (dateFilter.datePeriod) {
+            param.datePeriod = dateFilter.datePeriod;
+        }
+        if (!isNil_1(dateFilter.includeCurrentPeriod)) {
+            param.includeCurrentPeriod = dateFilter.includeCurrentPeriod;
+        }
+        if (dateFilterContent.negate) {
+            param.negate = true;
+        }
+        return param;
+    }
+    function convertFilterContentToParam(columnName, filterContent) {
+        var _a;
+        if (!(filterContent === null || filterContent === void 0 ? void 0 : filterContent.filterType))
+            return null;
+        const values = ((_a = filterContent.value) !== null && _a !== void 0 ? _a : [])
+            .map((value) => value === null || value === void 0 ? void 0 : value.key)
+            .filter((value) => !isNil_1(value));
+        const param = {
+            columnName,
+            operator: filterContent.filterType,
+            values,
+        };
+        if (filterContent.negate) {
+            param.negate = true;
+        }
+        return param;
+    }
+    function convertFilterToParams(columnName, filter) {
+        var _a, _b;
+        const dateParams = ((_a = filter === null || filter === void 0 ? void 0 : filter.dateFilterContent) !== null && _a !== void 0 ? _a : [])
+            .map((dateFilterContent) => convertDateFilterToParam(columnName, dateFilterContent));
+        const contentParams = ((_b = filter === null || filter === void 0 ? void 0 : filter.filterContent) !== null && _b !== void 0 ? _b : [])
+            .map((filterContent) => convertFilterContentToParam(columnName, filterContent));
+        return [...dateParams, ...contentParams]
+            .filter((param) => param !== null);
+    }
+    /**
+     * Runtime filters need no reshaping, but they still come off the wire as JSON,
+     * so a malformed entry is possible. Skip it rather than pass it through: an
+     * entry missing a column, operator or values array fails
+     * `isValidUpdateFiltersPayload`, and that rejects the *whole* `filters` array,
+     * so one bad runtime filter would drop every other converted filter with it.
+     * @param runtimeFilter A runtime filter from the `FilterChanged` payload.
+     */
+    function convertRuntimeFilterToParam(runtimeFilter) {
+        const { columnName, operator, values } = runtimeFilter !== null && runtimeFilter !== void 0 ? runtimeFilter : {};
+        if (typeof columnName !== 'string' || !columnName)
+            return null;
+        if (typeof operator !== 'string' || !operator)
+            return null;
+        if (!Array.isArray(values))
+            return null;
+        return { columnName, operator, values };
+    }
+    /**
+     * Mirrors `isValidApplicability` in `hostEventClient/utils`: a `TAB` or `GROUP`
+     * scope is meaningless without a `targetId`, and `UpdateFilters` rejects the
+     * whole `filters` array when any entry carries a malformed `applicability`.
+     * @param applicability Scope taken from the `FilterChanged` payload.
+     */
+    function isUsableApplicability(applicability) {
+        const levels = Object.values(exports.ApplicabilityLevel);
+        if (!levels.includes(applicability.level))
+            return false;
+        if (applicability.level === exports.ApplicabilityLevel.Liveboard)
+            return true;
+        return typeof applicability.targetId === 'string' && applicability.targetId.trim().length > 0;
+    }
+    function convertFilterGroupToParams(filterGroup) {
+        var _a, _b;
+        const columnName = (_a = filterGroup === null || filterGroup === void 0 ? void 0 : filterGroup.columnInfo) === null || _a === void 0 ? void 0 : _a.name;
+        if (!columnName)
+            return [];
+        const { applicability } = filterGroup;
+        // A filter scoped to a tab or group has to keep that scope. Replaying it
+        // without `applicability` would silently widen it to the whole Liveboard,
+        // changing what every other tab shows. If a scope is present but unusable,
+        // skip the filter: widening is worse than dropping, and a malformed
+        // applicability would fail validation for every other filter alongside it.
+        if (!isNil_1(applicability) && !isUsableApplicability(applicability))
+            return [];
+        const params = ((_b = filterGroup.filters) !== null && _b !== void 0 ? _b : [])
+            .flatMap((filter) => convertFilterToParams(columnName, filter));
+        return isNil_1(applicability) ? params : params.map((param) => ({ ...param, applicability }));
+    }
+    /**
+     * Converts the payload emitted by {@link EmbedEvent.FilterChanged} into the
+     * payload shape expected by {@link HostEvent.UpdateFilters}, so the same
+     * filter state can be captured and re-applied later, for example on a
+     * subsequent page load.
+     *
+     * Both the Liveboard filters and the runtime filters present in the
+     * `FilterChanged` payload are included in the returned `filters` array.
+     *
+     * Note: a column with multiple date-filter conditions (e.g. an OR of two
+     * date ranges) is not guaranteed to round-trip losslessly - `HostEvent.UpdateFilters`
+     * treats date filters as replace-not-merge per column, so only the last
+     * converted entry for such a column will apply.
+     * @param filterChangedPayload The filter state carried by the
+     * `EmbedEvent.FilterChanged` callback, which is `payload.data` - the
+     * callback argument is the event envelope, and the filters sit under its
+     * `data` key.
+     * @example
+     * ```js
+     * let savedFilters;
+     * liveboardEmbed.on(EmbedEvent.FilterChanged, (payload) => {
+     *     savedFilters = convertFilterChangedToUpdateFiltersPayload(payload.data);
+     * });
+     *
+     * // later, e.g. after a fresh page load
+     * liveboardEmbed.trigger(HostEvent.UpdateFilters, savedFilters);
+     * ```
+     */
+    function convertFilterChangedToUpdateFiltersPayload(filterChangedPayload) {
+        var _a, _b;
+        const liveboardFilterParams = ((_a = filterChangedPayload === null || filterChangedPayload === void 0 ? void 0 : filterChangedPayload.liveboardFilters) !== null && _a !== void 0 ? _a : [])
+            .flatMap(convertFilterGroupToParams);
+        const runtimeFilterParams = ((_b = filterChangedPayload === null || filterChangedPayload === void 0 ? void 0 : filterChangedPayload.runtimeFilters) !== null && _b !== void 0 ? _b : [])
+            .map(convertRuntimeFilterToParam)
+            .filter((param) => param !== null);
+        return { filters: [...liveboardFilterParams, ...runtimeFilterParams] };
+    }
+
     /**
      * Starts an automatic renderer that watches the DOM for iframes containing
      * the `tsmcp=true` query parameter and replaces them with fully configured
@@ -34304,6 +34637,7 @@ query GetEurekaResults($params: Input_eureka_SearchRequest) {
     exports.SearchEmbed = SearchEmbed;
     exports.SpotterAgentEmbed = SpotterAgentEmbed;
     exports.SpotterEmbed = SpotterEmbed;
+    exports.convertFilterChangedToUpdateFiltersPayload = convertFilterChangedToUpdateFiltersPayload;
     exports.createLiveboardWithAnswers = createLiveboardWithAnswers;
     exports.executeTML = executeTML;
     exports.exportTML = exportTML;