@thoughtspot/visual-embed-sdk 1.46.2 → 1.46.3

package/package.json

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

package/src/auth.spec.ts

@@ -283,7 +283,7 @@ describe('Unit test for auth', () => {
             text: () => Promise.resolve('abc'),
         } as any));
         jest.spyOn(authService, 'fetchAuthPostService').mockImplementation(() =>
-            // eslint-disable-next-line prefer-promise-reject-errors, implicit-arrow-linebreak
+             
             Promise.reject({
                 status: 500,
             }));

package/src/auth.ts

@@ -19,11 +19,11 @@ import { getSessionInfo, getPreauthInfo } from './utils/sessionInfoService';
 import { ERROR_MESSAGE } from './errors';
 import { resetAllCachedServices } from './utils/resetServices';
 
-// eslint-disable-next-line import/no-mutable-exports
+ 
 export let loggedInStatus = false;
-// eslint-disable-next-line import/no-mutable-exports
+ 
 export let samlAuthWindow: Window = null;
-// eslint-disable-next-line import/no-mutable-exports
+ 
 export let samlCompletionPromise: Promise<void> = null;
 
 let releaseVersion = '';

package/src/authToken.spec.ts

@@ -129,7 +129,8 @@ describe('AuthToken Unit tests', () => {
             expect(token).toBe(newToken);
             // Should not validate cached token (condition at line 23 is false)
             expect(validateAuthTokenSpy).not.toHaveBeenCalledWith(config, cachedToken, true);
-            // But should validate new token (though it returns early when disableTokenVerification is true)
+            // But should validate new token (though it returns early when
+            // disableTokenVerification is true)
             expect(validateAuthTokenSpy).toHaveBeenCalledWith(config, newToken);
             expect(getAuthTokenMock).toHaveBeenCalled();
 

package/src/authToken.ts

@@ -83,7 +83,7 @@ export const validateAuthToken = async (
 
     if (cachedAuthToken && cachedAuthToken === authToken) {
         if (!embedConfig.suppressErrorAlerts && !suppressAlert) {
-            // eslint-disable-next-line no-alert
+             
             alert(ERROR_MESSAGE.DUPLICATE_TOKEN_ERR);
         }
         throw new Error(ERROR_MESSAGE.DUPLICATE_TOKEN_ERR);

package/src/embed/app.ts

@@ -570,7 +570,8 @@ export interface AppViewConfig extends AllEmbedViewConfig {
     isLiveboardStylingAndGroupingEnabled?: boolean;
 
     /**
-     * This flag is used to enable/disable the png embedding of liveboard in scheduled mails
+     * This flag is used to enable/disable the png embedding of liveboard in scheduled
+     * mails
      *
      * Supported embed types: `AppEmbed`, `LiveboardEmbed`
      * @type {boolean}

package/src/embed/auto-frame-renderer.spec.ts

@@ -0,0 +1,266 @@
+import { startAutoMCPFrameRenderer } from './auto-frame-renderer';
+import { Param, AuthType } from '../types';
+import { init } from '../index';
+import * as authInstance from '../auth';
+import { TsEmbed } from './ts-embed';
+import {
+    getDocumentBody,
+} from '../test/test-utils';
+
+const thoughtSpotHost = 'tshost';
+
+describe('startAutoMCPFrameRenderer', () => {
+    let renderIFrameSpy: jest.SpyInstance;
+    let getEmbedBasePathSpy: jest.SpyInstance;
+
+    beforeAll(() => {
+        init({
+            thoughtSpotHost,
+            authType: AuthType.None,
+        });
+        jest.spyOn(authInstance, 'postLoginService').mockImplementation(() => Promise.resolve(undefined));
+        jest.spyOn(window, 'alert').mockImplementation(() => undefined);
+    });
+
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+        getEmbedBasePathSpy = jest.spyOn(
+            TsEmbed.prototype as any,
+            'getEmbedBasePath',
+        ).mockImplementation(function (this: any, query: string) {
+            return `http://${thoughtSpotHost}/?${query}#`;
+        });
+        renderIFrameSpy = jest.spyOn(
+            TsEmbed.prototype as any,
+            'renderIFrame',
+        ).mockResolvedValue(undefined);
+    });
+
+    afterEach(() => {
+        renderIFrameSpy.mockRestore();
+        getEmbedBasePathSpy.mockRestore();
+    });
+
+    describe('MutationObserver setup', () => {
+        test('should return a MutationObserver', () => {
+            const observer = startAutoMCPFrameRenderer();
+            expect(observer).toBeInstanceOf(MutationObserver);
+            observer.disconnect();
+        });
+
+        test('should observe document.body with childList and subtree', () => {
+            const observeSpy = jest.spyOn(MutationObserver.prototype, 'observe');
+            const observer = startAutoMCPFrameRenderer();
+            expect(observeSpy).toHaveBeenCalledWith(document.body, {
+                childList: true,
+                subtree: true,
+            });
+            observer.disconnect();
+            observeSpy.mockRestore();
+        });
+    });
+
+    describe('iframe detection via tsmcp param', () => {
+        test('should process directly-added iframes with tsmcp=true', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const iframe = document.createElement('iframe');
+            iframe.src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true#/embed/viz/lb1/tab1`;
+            document.body.appendChild(iframe);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).toHaveBeenCalled();
+            observer.disconnect();
+        });
+
+        test('should not process iframes without tsmcp param', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const iframe = document.createElement('iframe');
+            iframe.src = `https://${thoughtSpotHost}/v2/?embedApp=true#/embed/viz/lb1`;
+            document.body.appendChild(iframe);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).not.toHaveBeenCalled();
+            observer.disconnect();
+        });
+
+        test('should process tsmcp iframes nested inside added elements', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const wrapper = document.createElement('div');
+            const iframe = document.createElement('iframe');
+            iframe.src = `https://${thoughtSpotHost}/?${Param.Tsmcp}=true`;
+            wrapper.appendChild(iframe);
+            document.body.appendChild(wrapper);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).toHaveBeenCalled();
+            observer.disconnect();
+        });
+
+        test('should not process nested iframes without tsmcp param', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const wrapper = document.createElement('div');
+            const iframe = document.createElement('iframe');
+            iframe.src = `https://${thoughtSpotHost}/?embedApp=true`;
+            wrapper.appendChild(iframe);
+            document.body.appendChild(wrapper);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).not.toHaveBeenCalled();
+            observer.disconnect();
+        });
+
+        test('should ignore non-iframe element nodes', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const div = document.createElement('div');
+            div.textContent = `${Param.Tsmcp}=true`;
+            document.body.appendChild(div);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).not.toHaveBeenCalled();
+            observer.disconnect();
+        });
+
+        test('should ignore text nodes', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const text = document.createTextNode('tsmcp=true');
+            document.body.appendChild(text);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).not.toHaveBeenCalled();
+            observer.disconnect();
+        });
+
+        test('should process multiple tsmcp iframes in one mutation', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const wrapper = document.createElement('div');
+            const iframe1 = document.createElement('iframe');
+            iframe1.src = `https://${thoughtSpotHost}/?${Param.Tsmcp}=true&id=1`;
+            const iframe2 = document.createElement('iframe');
+            iframe2.src = `https://${thoughtSpotHost}/?${Param.Tsmcp}=true&id=2`;
+            wrapper.appendChild(iframe1);
+            wrapper.appendChild(iframe2);
+            document.body.appendChild(wrapper);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).toHaveBeenCalledTimes(2);
+            observer.disconnect();
+        });
+
+        test('should ignore iframes with invalid src URLs', async () => {
+            const observer = startAutoMCPFrameRenderer();
+
+            const iframe = document.createElement('iframe');
+            iframe.src = 'about:blank';
+            document.body.appendChild(iframe);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(renderIFrameSpy).not.toHaveBeenCalled();
+            observer.disconnect();
+        });
+    });
+
+    describe('handleInsertionIntoDOM override', () => {
+        test('should replace the original iframe when renderIFrame inserts DOM', async () => {
+            renderIFrameSpy.mockRestore();
+
+            const replaceSpy = jest.fn();
+
+            renderIFrameSpy = jest.spyOn(
+                TsEmbed.prototype as any,
+                'renderIFrame',
+            ).mockImplementation(async function (this: any) {
+                const newIframe = document.createElement('iframe');
+                newIframe.src = 'https://replaced.example.com';
+                this.frameToReplace.replaceWith = replaceSpy;
+                this.handleInsertionIntoDOM(newIframe);
+            });
+
+            const observer = startAutoMCPFrameRenderer();
+
+            const iframe = document.createElement('iframe');
+            iframe.src = `https://${thoughtSpotHost}/?${Param.Tsmcp}=true`;
+            document.body.appendChild(iframe);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(replaceSpy).toHaveBeenCalled();
+            observer.disconnect();
+        });
+    });
+
+    describe('viewConfig forwarding', () => {
+        test('should accept empty viewConfig', () => {
+            const observer = startAutoMCPFrameRenderer({});
+            expect(observer).toBeInstanceOf(MutationObserver);
+            observer.disconnect();
+        });
+
+        test('should accept no arguments (default empty config)', () => {
+            const observer = startAutoMCPFrameRenderer();
+            expect(observer).toBeInstanceOf(MutationObserver);
+            observer.disconnect();
+        });
+    });
+
+    describe('getMCPIframeSrc URL construction', () => {
+        test('should strip tsmcp param and merge embed params into rendered src', async () => {
+            let capturedSrc = '';
+            renderIFrameSpy.mockRestore();
+            renderIFrameSpy = jest.spyOn(
+                TsEmbed.prototype as any,
+                'renderIFrame',
+            ).mockImplementation(async function (this: any, src: string) {
+                capturedSrc = src;
+            });
+
+            const observer = startAutoMCPFrameRenderer();
+
+            const iframe = document.createElement('iframe');
+            iframe.src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true&customParam=hello#/embed/viz`;
+            document.body.appendChild(iframe);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(capturedSrc).not.toContain(`${Param.Tsmcp}=true`);
+            expect(capturedSrc).toContain('customParam=hello');
+            observer.disconnect();
+        });
+
+        test('should preserve hash from original iframe src', async () => {
+            let capturedSrc = '';
+            renderIFrameSpy.mockRestore();
+            renderIFrameSpy = jest.spyOn(
+                TsEmbed.prototype as any,
+                'renderIFrame',
+            ).mockImplementation(async function (this: any, src: string) {
+                capturedSrc = src;
+            });
+
+            const observer = startAutoMCPFrameRenderer();
+
+            const iframe = document.createElement('iframe');
+            iframe.src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true#/embed/viz/lb123`;
+            document.body.appendChild(iframe);
+
+            await new Promise((r) => setTimeout(r, 50));
+
+            expect(capturedSrc).toContain('/embed/viz/lb123');
+            observer.disconnect();
+        });
+    });
+});

package/src/embed/auto-frame-renderer.ts

@@ -0,0 +1,152 @@
+import { AutoMCPFrameRendererViewConfig, Param } from "../types";
+import { TsEmbed } from "./ts-embed";
+import { getQueryParamString } from "../utils";
+
+
+/**
+ * Starts an automatic renderer that watches the DOM for iframes containing
+ * the `tsmcp=true` query parameter and replaces them with fully configured
+ * ThoughtSpot embed iframes. The query parameter is automatically added by
+ * the ThoughtSpot MCP server.
+ *
+ * A {@link MutationObserver} is set up on `document.body` to detect both
+ * directly added iframes and iframes nested within added container elements.
+ * Each matching iframe is replaced in-place with a new ThoughtSpot embed
+ * iframe that merges the original iframe's query parameters with the SDK
+ * embed parameters.
+ *
+ * Call {@link MutationObserver.disconnect | observer.disconnect()} on the
+ * returned observer to stop monitoring the DOM.
+ *
+ * @param viewConfig - Optional configuration for the auto-rendered embeds.
+ *   Accepts all properties from {@link AutoMCPFrameRendererViewConfig}.
+ *   Defaults to an empty config.
+ * @returns A {@link MutationObserver} instance that is actively observing
+ *   `document.body`. Disconnect it when monitoring is no longer needed.
+ *
+ * @example
+ * ```js
+ * import { startAutoMCPFrameRenderer } from '@thoughtspot/visual-embed-sdk';
+ *
+ * // Start watching the DOM for tsmcp iframes
+ * const observer = startAutoMCPFrameRenderer({
+ *   // optional view config overrides
+ * });
+ *
+ * // Later, stop watching
+ * observer.disconnect();
+ * ```
+ * 
+ * @example
+ * Detailed example of how to use the auto-frame renderer:
+ * [Python React Agent Simple UI](https://github.com/thoughtspot/developer-examples/tree/main/mcp/python-react-agent-simple-ui)
+ */
+export function startAutoMCPFrameRenderer(viewConfig: AutoMCPFrameRendererViewConfig = {}) {
+
+    const replaceWithMCPIframe = (iframe: HTMLIFrameElement) => {
+        const autoMCPFrameRenderer = new AutoFrameRenderer(viewConfig);
+        autoMCPFrameRenderer.replaceIframe(iframe);
+    };
+
+    const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+            for (const node of Array.from(mutation.addedNodes)) {
+                if (node instanceof HTMLIFrameElement && isTSMCPIframe(node)) {
+                    replaceWithMCPIframe(node);
+                }
+                if (node instanceof HTMLElement) {
+                    node.querySelectorAll('iframe').forEach((iframe) => {
+                        if (isTSMCPIframe(iframe)) {
+                            replaceWithMCPIframe(iframe);
+                        }
+                    });
+                }
+            }
+        }
+    });
+
+    observer.observe(document.body, { childList: true, subtree: true });
+
+    return observer;
+}
+
+function isTSMCPIframe(iframe: HTMLIFrameElement) {
+    try {
+        const url = new URL(iframe.src);
+        return url.searchParams.get(Param.Tsmcp) === 'true';
+    } catch (e) {
+        // The iframe src might not be a valid URL (e.g., 'about:blank').
+        return false;
+    }
+}
+
+/**
+ * Embed component that automatically replaces a plain iframe with a
+ * ThoughtSpot embed iframe. It merges the SDK's embed parameters with
+ * the original iframe's query parameters (stripping the `tsmcp` marker)
+ * and swaps the original iframe element in the DOM.
+ *
+ * This class is used internally by {@link startAutoMCPFrameRenderer} and
+ * is not intended to be instantiated directly.
+ */
+class AutoFrameRenderer extends TsEmbed {
+    private frameToReplace: HTMLIFrameElement;
+
+    constructor(protected viewConfig: AutoMCPFrameRendererViewConfig) {
+        viewConfig.embedComponentType = 'auto-frame-renderer';
+        const container = document.createElement('div');
+        super(container, viewConfig);
+    }
+
+    /**
+     * Builds the final iframe `src` by merging the SDK embed parameters
+     * with the query parameters already present on the source iframe URL.
+     * The `tsmcp` marker param is removed so it does not propagate to the
+     * ThoughtSpot application.
+     *
+     * @param sourceSrc - The original iframe's `src` URL string.
+     * @returns The constructed URL to use for the ThoughtSpot embed iframe.
+     */
+    private getMCPIframeSrc(sourceSrc: string) {
+        const queryParams = this.getEmbedParamsObject();
+        const sourceURL = new URL(sourceSrc);
+        const existingQueryParams = sourceURL.searchParams;
+        const existingQueryParamsObject = Object.fromEntries(existingQueryParams);
+        delete existingQueryParamsObject[Param.Tsmcp];
+
+        const mergedQueryParams = { ...queryParams, ...existingQueryParamsObject };
+        const mergedQueryParamsString = getQueryParamString(mergedQueryParams);
+        const frameSrc = `${this.getEmbedBasePath(mergedQueryParamsString)}${sourceURL.hash.replace('#', '')}`;
+        return frameSrc;
+    }
+
+    /**
+     * Overrides the base insertion behavior so the new embed iframe
+     * replaces the original iframe in-place rather than being appended
+     * to a container element. Falls back to the default behavior when
+     * no iframe has been set for replacement.
+     */
+    protected handleInsertionIntoDOM(child: string | Node): void {
+        if (this.frameToReplace) {
+            this.frameToReplace.replaceWith(child);
+        } else {
+            super.handleInsertionIntoDOM(child);
+        }
+    }
+
+    /**
+     * Replaces the given iframe with a new ThoughtSpot embed iframe.
+     *
+     * The original iframe's `src` is used to derive the embed URL, and
+     * once the new iframe is rendered it takes the original's place in
+     * the DOM tree.
+     *
+     * @param iframe - The existing `<iframe>` element to replace.
+     */
+    public async replaceIframe(iframe: HTMLIFrameElement): Promise<void> {
+        this.frameToReplace = iframe;
+        const src = this.getMCPIframeSrc(iframe.src);
+        await this.renderIFrame(src);
+    }
+}
+

package/src/embed/base.spec.ts

@@ -1,4 +1,4 @@
-/* eslint-disable no-console */
+ 
 /* eslint-disable @typescript-eslint/no-shadow */
 import EventEmitter from 'eventemitter3';
 import { EmbedConfig } from '../index';

package/src/embed/base.ts

@@ -1,5 +1,5 @@
-/* eslint-disable camelcase */
-/* eslint-disable import/no-mutable-exports */
+ 
+ 
 /**
  * Copyright (c) 2022
  *
@@ -36,7 +36,6 @@ import { getEmbedConfig, setEmbedConfig } from './embedConfig';
 import { getQueryParamString, getValueFromWindow, isWindowUndefined, storeValueInWindow } from '../utils';
 import { resetAllCachedServices } from '../utils/resetServices';
 import { reload } from '../utils/processTrigger';
-import { ERROR_MESSAGE } from '../errors';
 
 const CONFIG_DEFAULTS: Partial<EmbedConfig> = {
     loginFailedMessage: 'Not logged in',
@@ -116,7 +115,7 @@ export const prefetch = (
     additionalFlags?: { [key: string]: string | number | boolean },
 ): void => {
     if (url === '') {
-        // eslint-disable-next-line no-console
+         
         logger.warn('The prefetch method does not have a valid URL');
     } else {
         const features = prefetchFeatures || [PrefetchFeatures.FullApp];
@@ -142,9 +141,9 @@ export const prefetch = (
                     iFrame.style.height = '0';
                     iFrame.style.border = '0';
 
-                    // Make it 'fixed' to keep it in a different stacking context.
-                    //   This should solve the focus behaviours inside the iframe from
-                    //   interfering with main body.
+                    // Make it 'fixed' to keep it in a different stacking
+                    // context. This should solve the focus behaviours inside
+                    // the iframe from interfering with main body.
                     iFrame.style.position = 'fixed';
                     // Push it out of viewport.
                     iFrame.style.top = '100vh';
@@ -323,7 +322,7 @@ export const renderInQueue = (fn: (next?: (val?: any) => void) => Promise<any>):
         return renderQueue;
     }
     // Sending an empty function to keep it consistent with the above usage.
-    return fn(() => {}); // eslint-disable-line @typescript-eslint/no-empty-function
+    return fn(() => {});  
 };
 
 /**

package/src/embed/hostEventClient/host-event-client.ts

@@ -48,7 +48,7 @@ export class HostEventClient {
 
       if (!response) {
           const error = `No answer found${parameters.vizId ? ` for vizId: ${parameters.vizId}` : ''}.`;
-          // eslint-disable-next-line no-throw-literal
+           
           throw { error };
       }
 
@@ -57,7 +57,7 @@ export class HostEventClient {
         || (response.value as any)?.error;
 
       if (errors) {
-      // eslint-disable-next-line no-throw-literal
+       
           throw { error: response.error };
       }
 

package/src/embed/liveboard.spec.ts

@@ -914,7 +914,8 @@ describe('Liveboard/viz embed tests', () => {
             } as LiveboardViewConfig);
             liveboardEmbed.render();
             await executeAfterWait(() => {
-                // URL should be: #/embed/viz/{id}/tab/{tabId}/{vizId}?view={viewId}
+                // URL should be:
+                // #/embed/viz/{id}/tab/{tabId}/{vizId}?view={viewId}
                 expect(getIFrameSrc()).toMatch(
                     new RegExp(
                         `#/embed/viz/${liveboardId}/tab/${activeTabId}/${vizId}\\?view=${personalizedViewId}`,
@@ -1010,7 +1011,8 @@ describe('Liveboard/viz embed tests', () => {
                 } as LiveboardViewConfig);
                 liveboardEmbed.render();
                 await executeAfterWait(() => {
-                    // URL: #/embed/viz/{id}/tab/{tabId}?view={viewId} (view at END, not middle)
+                    // URL: #/embed/viz/{id}/tab/{tabId}?view={viewId} (view at
+                    // END, not middle)
                     expect(getIFrameSrc()).toMatch(
                         new RegExp(
                             `#/embed/viz/${liveboardId}/tab/${activeTabId}\\?view=${workaroundViewId}`,

package/src/embed/liveboard.ts

@@ -371,7 +371,8 @@ export interface LiveboardViewConfig extends BaseViewConfig, LiveboardOtherViewC
      */
     isLiveboardStylingAndGroupingEnabled?: boolean;
     /**
-     * This flag is used to enable/disable the png embedding of liveboard in scheduled mails
+     * This flag is used to enable/disable the png embedding of liveboard in scheduled
+     * mails
      *
      * Supported embed types: `AppEmbed`, `LiveboardEmbed`
      * @type {boolean}
@@ -730,8 +731,9 @@ export class LiveboardEmbed extends V1Embed {
         activeTabId: string,
         personalizedViewId?: string,
     ) {
-        // Extract view from liveboardId if passed along with it (legacy approach)
-        // View must be appended as query param at the end, not embedded in path
+        // Extract view from liveboardId if passed along with it (legacy
+        // approach) View must be appended as query param at the end, not
+        // embedded in path
         let liveboardGuid = liveboardId;
         let legacyViewId: string | undefined;
 
@@ -742,7 +744,8 @@ export class LiveboardEmbed extends V1Embed {
             legacyViewId = params.get('view') || undefined;
         }
 
-        // personalizedViewId takes precedence over legacyViewId (when passed as part of liveboardId)
+        // personalizedViewId takes precedence over legacyViewId (when passed
+        // as part of liveboardId)
         const effectiveViewId = personalizedViewId || legacyViewId;
 
         let suffix = `/embed/viz/${liveboardGuid}`;

package/src/embed/sage.ts

@@ -147,7 +147,7 @@ export class SageEmbed extends V1Embed {
      */
     protected viewConfig: SageViewConfig;
 
-    // eslint-disable-next-line no-useless-constructor
+     
     constructor(domSelector: DOMSelector, viewConfig: SageViewConfig) {
         viewConfig.embedComponentType = 'SageEmbed';
         super(domSelector, viewConfig);

package/src/embed/search.spec.ts

@@ -527,7 +527,7 @@ describe('Search embed tests', () => {
     test('should set dataPanelCustomGroupsAccordionInitialState to EXPAND_FIRST when passed', async () => {
         const searchEmbed = new SearchBarEmbed(getRootEl() as any, {
             ...defaultViewConfig,
-            // eslint-disable-next-line max-len
+             
         });
         searchEmbed.render();
         await executeAfterWait(() => {
@@ -541,7 +541,7 @@ describe('Search embed tests', () => {
     test('should set dataPanelCustomGroupsAccordionInitialState to EXPAND_FIRST when passed', async () => {
         const searchEmbed = new SearchEmbed(getRootEl(), {
             ...defaultViewConfig,
-            // eslint-disable-next-line max-len
+             
             dataPanelCustomGroupsAccordionInitialState:
                 DataPanelCustomColumnGroupsAccordionState.EXPAND_FIRST,
         });

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

@@ -3056,7 +3056,8 @@ describe('Unit test case for ts embed', () => {
                     expect.any(Object),
                     true
                 );
-                // Check that logger.error was called with the token refresh error
+                // Check that logger.error was called with the token refresh
+                // error
                 const errorCalls = (logger.error as jest.Mock).mock.calls.filter(
                     (call) => call[0]?.includes(ERROR_MESSAGE.INVALID_TOKEN_ERROR) && call[0]?.includes('Token fetch failed')
                 );