@thoughtspot/visual-embed-sdk 1.49.0 → 1.49.2

package/dist/tsembed-react.es.js

@@ -1,4 +1,4 @@
-/* @thoughtspot/visual-embed-sdk version 1.49.0 */
+/* @thoughtspot/visual-embed-sdk version 1.49.2 */
 'use client';
 import * as React from 'react';
 import React__default, { useRef, useCallback } from 'react';
@@ -2411,11 +2411,30 @@ var HostEvent;
     /**
      * Navigate to a specific page in the embedded ThoughtSpot application.
      * This is the same as calling `appEmbed.navigateToPage(path, true)`.
-     * @param - `path` - the path to navigate to go forward or back. The path value can
-     * be a number; for example, `1`, `-1`.
+     *
+     * Accepts either a plain value or an object with `path`
+     * and an optional `replace` flag.
+     *
+     * @param data - A string path, a numeric history delta, or an object
+     *   `{ path: string | number, replace?: boolean }`.
+     *   - `path` — the route to navigate to, or a history delta such as `1`
+     *     or `-1` (calls `window.history.go()`).
+     *   - `replace` — when `true`, replaces the current history entry instead
+     *     of pushing a new one (uses `window.location.replace`).
+     *
      * @example
      * ```js
-     * appEmbed.navigateToPage(-1)
+     * // Preferred: use navigateToPage directly
+     * appEmbed.navigateToPage(-1);
+     *
+     * // Numeric delta — go back one step
+     * appEmbed.trigger(HostEvent.Navigate, -1);
+     *
+     * // String path — push a new history entry
+     * appEmbed.trigger(HostEvent.Navigate, 'home');
+     *
+     * // Object format — replace current history entry
+     * appEmbed.trigger(HostEvent.Navigate, { path: 'home', replace: true }); // SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
      * ```
      * @version SDK: 1.12.0 | ThoughtSpot: 8.4.0.cl, 8.4.1.sw
      */
@@ -4404,6 +4423,7 @@ var Param;
     Param["EnableLiveboardDataCache"] = "enableLiveboardDataCache";
     Param["SpotterFileUploadEnabled"] = "spotterFileUploadEnabled";
     Param["SpotterFileUploadFileTypes"] = "spotterFileUploadFileTypes";
+    Param["IsStarterPromptsEnabled"] = "enableStarterPrompts";
 })(Param || (Param = {}));
 /**
  * ThoughtSpot application pages include actions and menu commands
@@ -5046,6 +5066,16 @@ var Action;
      * @version SDK: 1.9.0 | ThoughtSpot: 8.1.0.cl, 8.4.1.sw
      */
     Action["AddToFavorites"] = "addToFavorites";
+    /**
+     * Remove from Favorites option in home page v3 sidebar.
+     * Allows removing an object from the user's favorites list from home-page v3 sidebar.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * disabledActions: [Action.RemoveFromFavorites]
+     * ```
+     */
+    Action["RemoveFromFavorites"] = "removeFromFavorites";
     /**
      * The edit icon on Liveboards (Classic experience).
      * @example
@@ -6103,6 +6133,20 @@ var Action;
      * ```
      */
     Action["SpotterViz"] = "spotterViz";
+    /**
+     * The reference-mode toggle button inside the SpotterViz chat input.
+     * When users enable reference mode, clicking tiles, filters, or
+     * parameters adds them as chat context. Hide this action to remove
+     * the reference-mode capability entirely.
+     * Visible by default.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterVizReferenceMode]
+     * disabledActions: [Action.SpotterVizReferenceMode]
+     * ```
+     */
+    Action["SpotterVizReferenceMode"] = "spotterVizReferenceMode";
     /**
      * Clears browser cache and fetches new data for liveboard ChartViz Containers.
      * Requires `enableLiveboardDataCache` to be enabled.
@@ -6579,7 +6623,9 @@ var TableContentDensity;
     TableContentDensity["Compact"] = "COMPACT";
 })(TableContentDensity || (TableContentDensity = {}));
 
-var version="1.49.0";
+var version$1="1.49.2";var pkg = {version:version$1};
+
+const { version } = pkg;
 
 const logFunctions = {
     [LogLevel.SILENT]: () => undefined,
@@ -6924,6 +6970,27 @@ const getRuntimeFilters = (runtimefilters) => getFilterQuery(runtimefilters || [
 function getDOMNode(domSelector) {
     return typeof domSelector === 'string' ? document.querySelector(domSelector) : domSelector;
 }
+/**
+ * Resolves a CSS selector to an element. `document.querySelector` cannot pierce
+ * shadow boundaries, so when the document lookup misses and a reference node is
+ * provided, this also searches the shadow root the reference node lives in —
+ * letting a selector target an element inside the same shadow root as the embed
+ * instead of silently falling back to the light DOM.
+ * @param selector CSS selector string.
+ * @param referenceNode Node whose shadow root is searched when the document lookup misses.
+ */
+function querySelectorAcrossShadowRoot(selector, referenceNode) {
+    var _a;
+    const fromDocument = document.querySelector(selector);
+    if (fromDocument) {
+        return fromDocument;
+    }
+    const rootNode = (_a = referenceNode === null || referenceNode === void 0 ? void 0 : referenceNode.getRootNode) === null || _a === void 0 ? void 0 : _a.call(referenceNode);
+    if (typeof ShadowRoot !== 'undefined' && rootNode instanceof ShadowRoot) {
+        return rootNode.querySelector(selector);
+    }
+    return null;
+}
 const deepMerge = (target, source) => merge(target, source);
 const getOperationNameFromQuery = (query) => {
     const regex = /(?:query|mutation)\s+(\w+)/;
@@ -9126,7 +9193,7 @@ class AnswerService {
     async getTML() {
         const { object } = await this.executeQuery(getAnswerTML, {});
         const edoc = object[0].edoc;
-        const YAML = await import('./index-_UGCSSDR.js');
+        const YAML = await import('./index-CS7yJ2Jj.js');
         const parsedDoc = YAML.parse(edoc);
         return {
             answer: {
@@ -19437,8 +19504,14 @@ function processTrigger(iFrame, messageType, thoughtSpotHost, data, context) {
             }
         }
         const channel = new MessageChannel();
+        // Close the messageChannel and resolve the promise if timeout.
+        const timeoutId = setTimeout(() => {
+            channel.port1.close();
+            res(new Error(ERROR_MESSAGE.TRIGGER_TIMED_OUT));
+        }, TRIGGER_TIMEOUT);
         channel.port1.onmessage = ({ data: responseData }) => {
             var _a;
+            clearTimeout(timeoutId);
             channel.port1.close();
             const error = (responseData === null || responseData === void 0 ? void 0 : responseData.error) || ((_a = responseData === null || responseData === void 0 ? void 0 : responseData.data) === null || _a === void 0 ? void 0 : _a.error);
             if (error) {
@@ -19448,11 +19521,6 @@ function processTrigger(iFrame, messageType, thoughtSpotHost, data, context) {
                 res(responseData);
             }
         };
-        // Close the messageChannel and resolve the promise if timeout.
-        setTimeout(() => {
-            channel.port1.close();
-            res(new Error(ERROR_MESSAGE.TRIGGER_TIMED_OUT));
-        }, TRIGGER_TIMEOUT);
         return postIframeMessage(iFrame, { type: messageType, data, context }, thoughtSpotHost, channel);
     });
 }
@@ -20217,6 +20285,14 @@ const processLegacyInterceptResponse = (payload) => {
  */
 const THOUGHTSPOT_PARAM_PREFIX = 'ts-';
 const TS_EMBED_ID = '_thoughtspot-embed';
+/**
+ * dataset key used to stash a custom preRenderContainer's original inline
+ * `position` while we override it to `relative`. Stored on the container (not
+ * per-instance) so the override can be reverted on destroy even when multiple
+ * pre-rendered embeds share the same container.
+ */
+const PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY = 'tsEmbedOriginalPosition';
+const PRERENDER_WRAPPER_ID_PREFIX = 'tsEmbed-pre-render-wrapper-';
 /**
  * The event id map from v2 event names to v1 event id
  * v1 events are the classic embed events implemented in Blink v1
@@ -20252,6 +20328,8 @@ class TsEmbed {
          */
         this.shouldEncodeUrlQueryParams = false;
         this.defaultHiddenActions = [Action.ReportError];
+        this.preRenderContainerEl = null;
+        this.containerScrollListener = null;
         /**
          * Handler for fullscreen change events
          */
@@ -21117,6 +21195,89 @@ class TsEmbed {
         placeholder.id = id.placeHolder;
         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.
+     */
+    resolvePreRenderContainerTarget() {
+        var _a;
+        const containerConfig = this.viewConfig.preRenderContainer;
+        let container = null;
+        if (typeof containerConfig === 'string') {
+            try {
+                // Resolve against the host's shadow root too, so a selector can
+                // target a container inside the same shadow DOM as the embed —
+                // document.querySelector alone cannot pierce shadow boundaries.
+                container = querySelectorAcrossShadowRoot(containerConfig, this.hostElement);
+            }
+            catch (e) {
+                logger$3.error(`Invalid CSS selector for preRenderContainer: ${containerConfig}`, e);
+            }
+        }
+        else if (containerConfig) {
+            container = containerConfig;
+        }
+        return (_a = container) !== null && _a !== void 0 ? _a : document.body;
+    }
+    /**
+     * Makes the container a positioning context for the absolutely positioned
+     * wrapper, stashing the original inline `position` on the element (once) so
+     * destroy() can restore it exactly, leaving no trace. Recording it on the
+     * element rather than per-instance lets the override be reverted even when
+     * embeds share the same container.
+     */
+    applyPreRenderContainerPositioning(container) {
+        if (container === document.body) {
+            return;
+        }
+        const pos = window.getComputedStyle(container).position;
+        if (pos === 'static') {
+            if (container.dataset[PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY] === undefined) {
+                container.dataset[PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY] = container.style.position;
+            }
+            container.style.position = 'relative';
+        }
+    }
+    /**
+     * 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.
+     */
+    reconcilePreRenderContainer() {
+        const wrapper = this.preRenderWrapper;
+        const stored = this.preRenderContainerEl;
+        // Nothing to reconcile until this instance resolved its container.
+        if (!wrapper || !stored) {
+            return;
+        }
+        const storedIsLive = stored === document.body || document.contains(stored);
+        if (storedIsLive && stored.contains(wrapper)) {
+            return;
+        }
+        const resolved = this.resolvePreRenderContainerTarget();
+        // Re-resolution yielded the same (still stale) element — nothing we can
+        // do, e.g. a detached container passed as an HTMLElement.
+        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.applyPreRenderContainerPositioning(resolved);
+        if (wrapper.parentNode !== resolved) {
+            resolved.appendChild(wrapper);
+        }
+        this.preRenderContainerEl = resolved;
+    }
     insertIntoDOMForPreRender(child) {
         const preRenderChild = this.createPreRenderChild(child);
         const preRenderWrapper = this.createPreRenderWrapper();
@@ -21136,7 +21297,10 @@ class TsEmbed {
         else {
             this.hidePreRender();
         }
-        document.body.appendChild(preRenderWrapper);
+        const targetContainer = this.resolvePreRenderContainerTarget();
+        this.preRenderContainerEl = targetContainer;
+        this.applyPreRenderContainerPositioning(targetContainer);
+        targetContainer.appendChild(preRenderWrapper);
     }
     insertIntoDOM(child) {
         var _a;
@@ -21575,6 +21739,50 @@ class TsEmbed {
         tsParams = tsParams ? `?${tsParams}` : '';
         return tsParams;
     }
+    /**
+     * Reverts the custom preRenderContainer's `position` to the value it had
+     * before we overrode it to `relative` (see insertIntoDOMForPreRender).
+     *
+     * We restore the original inline value rather than forcing `static`, and we
+     * skip the restore if another preRender wrapper is still mounted inside the
+     * same container — a shared container still needs the positioning context.
+     */
+    restorePreRenderContainerPosition() {
+        const container = this.preRenderContainerEl;
+        if (!container || container === document.body) {
+            return;
+        }
+        // Drop our reference up front so a destroyed embed never pins a
+        // detached container in memory; restoration uses the local handle.
+        this.preRenderContainerEl = null;
+        const originalPosition = container.dataset[PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY];
+        if (originalPosition === undefined) {
+            // We never overrode this container's position; nothing to restore.
+            return;
+        }
+        // This instance's own wrapper has already been removed by now, so any
+        // match here belongs to another embed still sharing the container — it
+        // continues to rely on the positioning context, so leave it in place.
+        const hasOtherWrapper = container.querySelector(`[id^="${PRERENDER_WRAPPER_ID_PREFIX}"]`);
+        if (hasOtherWrapper) {
+            return;
+        }
+        container.style.position = originalPosition;
+        delete container.dataset[PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY];
+    }
+    /**
+     * Detaches and clears the container scroll listener, if one is attached.
+     */
+    removeContainerScrollListener() {
+        if (!this.containerScrollListener) {
+            return;
+        }
+        const customContainer = this.preRenderContainerEl && this.preRenderContainerEl !== document.body
+            ? this.preRenderContainerEl
+            : null;
+        customContainer === null || customContainer === void 0 ? void 0 : customContainer.removeEventListener('scroll', this.containerScrollListener);
+        this.containerScrollListener = null;
+    }
     /**
      * Destroys the ThoughtSpot embed, and remove any nodes from the DOM.
      * @version SDK: 1.19.1 | ThoughtSpot: *
@@ -21583,8 +21791,10 @@ class TsEmbed {
         var _a, _b, _c;
         try {
             this.removeFullscreenChangeHandler();
+            this.removeContainerScrollListener();
             this.unsubscribeToEvents();
             (_a = this.preRenderWrapper) === null || _a === void 0 ? void 0 : _a.remove();
+            this.restorePreRenderContainerPosition();
             if (!this.isRendered) {
                 return;
             }
@@ -21694,15 +21904,19 @@ class TsEmbed {
             }
             this.hostElement.appendChild(this.insertedDomEl);
             this.syncPreRenderStyle();
+            const customContainer = this.preRenderContainerEl && this.preRenderContainerEl !== document.body
+                ? this.preRenderContainerEl
+                : null;
+            if (customContainer && !this.containerScrollListener) {
+                this.containerScrollListener = () => this.syncPreRenderStyle();
+                customContainer.addEventListener('scroll', this.containerScrollListener);
+            }
             if (!this.viewConfig.doNotTrackPreRenderSize) {
                 const observeTarget = (_a = this.insertedDomEl) !== null && _a !== void 0 ? _a : this.hostElement;
                 this.resizeObserver = new ResizeObserver((entries) => {
                     entries.forEach((entry) => {
-                        if (entry.contentRect && entry.target === observeTarget) {
-                            setStyleProperties(this.preRenderWrapper, {
-                                width: `${entry.contentRect.width}px`,
-                                height: `${entry.contentRect.height}px`,
-                            });
+                        if (entry.target === observeTarget) {
+                            this.syncPreRenderStyle();
                         }
                     });
                 });
@@ -21734,14 +21948,24 @@ class TsEmbed {
      * is not defined or not found.
      */
     syncPreRenderStyle() {
+        var _a;
         if (!this.isPreRenderConnected() || !this.getPreRenderPlaceHolderElement()) {
             logger$3.error(ERROR_MESSAGE.SYNC_STYLE_CALLED_BEFORE_RENDER);
             return;
         }
+        // Self-heal if the resolved container was remounted/detached, so we
+        // never measure a stale node (which would collapse the wrapper).
+        this.reconcilePreRenderContainer();
         const elBoundingClient = this.getPreRenderPlaceHolderElement().getBoundingClientRect();
+        const containerEl = this.preRenderContainerEl && this.preRenderContainerEl !== document.body
+            ? this.preRenderContainerEl
+            : null;
+        const containerRect = (_a = containerEl === null || containerEl === void 0 ? void 0 : containerEl.getBoundingClientRect()) !== null && _a !== void 0 ? _a : { x: 0, y: 0 };
+        const scrollX = containerEl ? containerEl.scrollLeft : window.scrollX;
+        const scrollY = containerEl ? containerEl.scrollTop : window.scrollY;
         setStyleProperties(this.preRenderWrapper, {
-            top: `${elBoundingClient.y + window.scrollY}px`,
-            left: `${elBoundingClient.x + window.scrollX}px`,
+            top: `${elBoundingClient.y - containerRect.y + scrollY}px`,
+            left: `${elBoundingClient.x - containerRect.x + scrollX}px`,
             width: `${elBoundingClient.width}px`,
             height: `${elBoundingClient.height}px`,
             position: 'absolute',
@@ -21768,6 +21992,7 @@ class TsEmbed {
             overflow: 'hidden',
         };
         setStyleProperties(this.preRenderWrapper, preRenderHideStyles);
+        this.removeContainerScrollListener();
         if (this.resizeObserver) {
             this.resizeObserver.disconnect();
         }
@@ -21786,7 +22011,7 @@ class TsEmbed {
      */
     getPreRenderIds() {
         return {
-            wrapper: `tsEmbed-pre-render-wrapper-${this.viewConfig.preRenderId}`,
+            wrapper: `${PRERENDER_WRAPPER_ID_PREFIX}${this.viewConfig.preRenderId}`,
             child: `tsEmbed-pre-render-child-${this.viewConfig.preRenderId}`,
             placeHolder: `tsEmbed-pre-render-placeholder-${this.viewConfig.preRenderId}`,
         };
@@ -22495,12 +22720,15 @@ let AppEmbed$1 = class AppEmbed extends V1Embed {
         }
         // Handle spotterChatConfig params
         if (spotterChatConfig) {
-            const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, } = spotterChatConfig;
+            const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, enableStarterPrompts, } = spotterChatConfig;
             setParamIfDefined(params, Param.HideToolResponseCardBranding, hideToolResponseCardBranding, true);
             setParamIfDefined(params, Param.ToolResponseCardBrandingLabel, toolResponseCardBrandingLabel);
             if (spotterFileUploadEnabled !== undefined) {
                 params[Param.SpotterFileUploadEnabled] = spotterFileUploadEnabled;
             }
+            if (enableStarterPrompts !== undefined) {
+                params[Param.IsStarterPromptsEnabled] = enableStarterPrompts;
+            }
             if (spotterFileUploadFileTypes !== undefined) {
                 params[Param.SpotterFileUploadFileTypes] = JSON.stringify(spotterFileUploadFileTypes);
             }
@@ -23056,12 +23284,15 @@ let LiveboardEmbed$1 = class LiveboardEmbed extends V1Embed {
         }
         // Handle spotterChatConfig params
         if (spotterChatConfig) {
-            const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, } = spotterChatConfig;
+            const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, enableStarterPrompts, } = spotterChatConfig;
             setParamIfDefined(params, Param.HideToolResponseCardBranding, hideToolResponseCardBranding, true);
             setParamIfDefined(params, Param.ToolResponseCardBrandingLabel, toolResponseCardBrandingLabel);
             if (spotterFileUploadEnabled !== undefined) {
                 params[Param.SpotterFileUploadEnabled] = spotterFileUploadEnabled;
             }
+            if (enableStarterPrompts !== undefined) {
+                params[Param.IsStarterPromptsEnabled] = enableStarterPrompts;
+            }
             if (spotterFileUploadFileTypes !== undefined) {
                 params[Param.SpotterFileUploadFileTypes] = JSON.stringify(spotterFileUploadFileTypes);
             }
@@ -23898,10 +24129,11 @@ let SpotterEmbed$1 = class SpotterEmbed extends TsEmbed {
         setParamIfDefined(queryParams, Param.EnableStopAnswerGenerationEmbed, enableStopAnswerGenerationEmbed, true);
         // Handle spotterChatConfig params
         if (spotterChatConfig) {
-            const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, } = spotterChatConfig;
+            const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, enableStarterPrompts, } = spotterChatConfig;
             setParamIfDefined(queryParams, Param.HideToolResponseCardBranding, hideToolResponseCardBranding, true);
             setParamIfDefined(queryParams, Param.ToolResponseCardBrandingLabel, toolResponseCardBrandingLabel);
             setParamIfDefined(queryParams, Param.SpotterFileUploadEnabled, spotterFileUploadEnabled, true);
+            setParamIfDefined(queryParams, Param.IsStarterPromptsEnabled, enableStarterPrompts, true);
             if (spotterFileUploadFileTypes !== undefined) {
                 queryParams[Param.SpotterFileUploadFileTypes] = JSON.stringify(spotterFileUploadFileTypes);
             }