@thoughtspot/visual-embed-sdk 1.49.3 → 1.50.0

package/src/mixpanel-service.spec.ts

@@ -89,4 +89,19 @@ describe('Unit test for mixpanel', () => {
         expect(logger.error).toHaveBeenCalled();
         expect(mixpanel.register_once).not.toHaveBeenCalled();
     });
+
+    test('logs error when mixpanel.init throws (covers catch block)', () => {
+        testResetMixpanel();
+        jest.spyOn(logger, 'error').mockImplementation(() => {});
+        (mixpanel.init as jest.Mock).mockImplementationOnce(() => {
+            throw new Error('mixpanel init failed');
+        });
+        const sessionInfo = {
+            mixpanelToken: 'abc123',
+            userGUID: '12345',
+            isPublicUser: false,
+        } as SessionInfo;
+        initMixpanel(sessionInfo);
+        expect(logger.error).toHaveBeenCalledWith('Error initializing mixpanel', expect.any(Error));
+    });
 });

package/src/types.ts

@@ -963,7 +963,8 @@ export interface BaseViewConfig extends ApiInterceptFlags {
      * The list of actions to completely remove from the embedded view.
      * Hidden actions are not visible to the user at all (fully removed from the UI).
      * Use this when you want to remove an action entirely.
-     * To keep an action visible but non-interactive (grayed out), use {@link disabledActions} instead.
+     * To keep an action visible but non-interactive (grayed out), use {@link
+     * disabledActions} instead.
      *
      * Supported embed types: `AppEmbed`, `LiveboardEmbed`, `SearchEmbed`, `SpotterAgentEmbed`, `SpotterEmbed`, `SearchBarEmbed`
      * @version SDK: 1.6.0 | ThoughtSpot: ts8.nov.cl, 8.4.1.sw
@@ -983,7 +984,8 @@ export interface BaseViewConfig extends ApiInterceptFlags {
      * (...), and the contextual menu. These will be only actions that
      * are visible to the user.
      * Use this as an allowlist — only the actions listed here will be shown.
-     * All other actions will be hidden. Use either this or {@link hiddenActions}, not both.
+     * All other actions will be hidden. Use either this or {@link hiddenActions}, not
+     * both.
      *
      * Supported embed types: `AppEmbed`, `LiveboardEmbed`, `SearchEmbed`, `SpotterAgentEmbed`, `SpotterEmbed`, `SearchBarEmbed`
      * @version SDK: 1.6.0 | ThoughtSpot: ts8.nov.cl, 8.4.1.sw
@@ -3760,10 +3762,11 @@ export enum EmbedEvent {
     EmbedPageContextChanged = 'EmbedPageContextChanged',
 
     /**
-     * Represents a special embed event that is triggered whenever any host event is subscribed.
+     * Represents a special embed event that is triggered whenever any host event is
+     * subscribed.
      *
-     * You can listen to this event when you need to dispatch a host event during load or render,
-     * particularly in situations where timing issues may occur.
+     * You can listen to this event when you need to dispatch a host event during load or
+     * render, particularly in situations where timing issues may occur.
      *
      * @example
      * ```js
@@ -6016,6 +6019,27 @@ export enum HostEvent {
      * ```
      */
     InitSpotterVizConversation = 'InitSpotterVizConversation',
+
+    /**
+     * Opens the SpotterViz panel.
+     * @version SDK: 1.50.0 | ThoughtSpot Cloud: 26.7.0.cl
+     * @example
+     * ```js
+     * liveboardEmbed.trigger(HostEvent.OpenSpotterVizPanel);
+     * ```
+     */
+    OpenSpotterVizPanel = 'OpenSpotterVizPanel',
+
+    /**
+     * Closes the SpotterViz panel.
+     * @version SDK: 1.50.0 | ThoughtSpot Cloud: 26.7.0.cl
+     * @example
+     * ```js
+     * liveboardEmbed.trigger(HostEvent.CloseSpotterVizPanel);
+     * ```
+     */
+    CloseSpotterVizPanel = 'CloseSpotterVizPanel',
+
     /**
      * Clears browser cache and fetches new data for liveboard ChartViz Containers.
      * Requires `enableLiveboardDataCache` to be enabled.
@@ -7972,7 +7996,73 @@ export enum Action {
      * ```
      * @version SDK: 1.49.0 | ThoughtSpot Cloud: 26.6.0.cl
      */
-    RefreshLiveboardBrowserCache = 'refreshLiveboardBrowserCache',    
+    RefreshLiveboardBrowserCache = 'refreshLiveboardBrowserCache',
+    /**
+     * Controls visibility and disable state of the share action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystShare]
+     * disabledActions: [Action.SpotterAnalystShare]
+     * ```
+     */
+    SpotterAnalystShare = 'spotterAnalystShare',
+    /**
+     * Controls visibility and disable state of the edit action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystEdit]
+     * disabledActions: [Action.SpotterAnalystEdit]
+     * ```
+     */
+    SpotterAnalystEdit = 'spotterAnalystEdit',
+    /**
+     * Controls visibility and disable state of the create action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystCreate]
+     * disabledActions: [Action.SpotterAnalystCreate]
+     * ```
+     */
+    SpotterAnalystCreate = 'spotterAnalystCreate',
+    /**
+     * Controls visibility and disable state of the delete action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystDelete]
+     * disabledActions: [Action.SpotterAnalystDelete]
+     * ```
+     */
+    SpotterAnalystDelete = 'spotterAnalystDelete',
+    /**
+     * Controls visibility and disable state of the make a copy action
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystMakeACopy]
+     * disabledActions: [Action.SpotterAnalystMakeACopy]
+     * ```
+     */
+    SpotterAnalystMakeACopy = 'spotterAnalystMakeACopy',
+    /**
+     * Controls visibility and disable state of the sidebar
+     * in the Spotter Analyst interface.
+     * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
+     * @example
+     * ```js
+     * hiddenActions: [Action.SpotterAnalystSidebar]
+     * disabledActions: [Action.SpotterAnalystSidebar]
+     * ```
+     */
+    SpotterAnalystSidebar = 'spotterAnalystSidebar',
 }
 export interface AnswerServiceType {
     getAnswer?: (offset: number, batchSize: number) => any;

package/src/utils/custom-actions.spec.ts

@@ -429,6 +429,34 @@ describe('getCustomActions function', () => {
         });
     });
 
+    describe('Empty allowed IDs edge cases', () => {
+        test('should show "none" as supported metadata IDs when target has no allowed metadata IDs (SPOTTER)', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.SPOTTER,
+                position: CustomActionsPosition.MENU,
+                metadataIds: { liveboardIds: ['lb-1'] },
+            } as any;
+            const result = getCustomActions([action]);
+            // Expect an error containing 'none' for unsupported metadataIds on SPOTTER
+            expect(result.errors.some((e) => e.includes('none'))).toBe(true);
+        });
+
+        test('should show "none" as supported data model IDs when target has no allowed data model IDs (LIVEBOARD)', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+                dataModelIds: { modelIds: ['model-1'] },
+            } as any;
+            const result = getCustomActions([action]);
+            // Expect an error containing 'none' for unsupported dataModelIds on LIVEBOARD
+            expect(result.errors.some((e) => e.includes('none'))).toBe(true);
+        });
+    });
+
     describe('Warnings', () => {
         test('should warn when action name length exceeds 30 characters', () => {
             // Arrange

package/src/utils/processData.spec.ts

@@ -279,6 +279,38 @@ describe('Unit test for process data', () => {
         mockHandleExitPresentMode.mockReset();
     });
 
+    test('AuthInit with payload.userGUID fallback when data.userGUID is absent', () => {
+        const e = {
+            type: EmbedEvent.AuthInit,
+            payload: { userGUID: 'payloadGUID' },
+        };
+        jest.spyOn(base, 'notifyAuthSuccess');
+        expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
+            type: e.type,
+            payload: { userGUID: 'payloadGUID' },
+            data: { userGUID: 'payloadGUID' },
+        });
+        expect(base.notifyAuthSuccess).toHaveBeenCalled();
+    });
+
+    test('process authFailure EmbeddedSSO with UNAUTHENTICATED_FAILURE suppresses login page', () => {
+        const e = {
+            type: EmbedEvent.AuthFailure,
+            data: { type: auth.AuthFailureType.UNAUTHENTICATED_FAILURE },
+        };
+        jest.spyOn(base, 'notifyAuthFailure');
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
+            loginFailedMessage: 'Hello',
+            authType: AuthType.EmbeddedSSO,
+            disableLoginFailurePage: false,
+        } as any);
+        const el: any = {};
+        processDataInstance.processEventData(e.type, e, '', el);
+        // isEmbeddedSSOInfoFailure=true so neither branch fires, innerHTML stays unset
+        expect(el.innerHTML).toBeUndefined();
+        expect(base.notifyAuthFailure).not.toHaveBeenCalled();
+    });
+
     test('should handle ClearInfoCache', () => {
         const mockResetCachedPreauthInfo = jest.spyOn(sessionInfoService, 'resetCachedPreauthInfo').mockImplementation(() => {});
         const mockResetCachedSessionInfo = jest.spyOn(sessionInfoService, 'resetCachedSessionInfo').mockImplementation(() => {});

package/src/utils/reporting.spec.ts

@@ -88,4 +88,31 @@ describe('ReportingObserver', () => {
 
         (window as any).ReportingObserver = currentObserver;
     });
+
+    test('should suppress alert but still log error when suppressErrorAlerts is true', () => {
+        let callBackPassed: any;
+        const NewMockRO = jest.fn().mockImplementation((callback: any) => {
+            callBackPassed = callback;
+            return ({ observe: jest.fn(), disconnect: jest.fn(), takeRecords: jest.fn() });
+        });
+        const currentObserver = (window as any).ReportingObserver;
+        (window as any).ReportingObserver = NewMockRO;
+
+        setEmbedConfig({
+            thoughtSpotHost: 'testHost',
+            authType: AuthType.None,
+            suppressErrorAlerts: true,
+        } as any);
+
+        const mockAlert = jest.fn();
+        window.alert = mockAlert;
+
+        registerReportingObserver(true);
+        callBackPassed([{ type: 'csp-violation', url: 'testHost', body: { effectiveDirective: 'frame-ancestors' } }]);
+
+        expect(mockAlert).not.toHaveBeenCalled();
+        expect(logger.error).toHaveBeenCalledWith(ERROR_MESSAGE.CSP_FRAME_HOST_VIOLATION_LOG_MESSAGE);
+
+        (window as any).ReportingObserver = currentObserver;
+    });
 });

package/src/utils/sessionInfoService.spec.ts

@@ -0,0 +1,151 @@
+import * as authServiceModule from './authService';
+import * as embedConfigModule from '../embed/embedConfig';
+import {
+    formatPreauthInfo,
+    getPreauthInfo,
+    getSessionInfo,
+    resetCachedPreauthInfo,
+    resetCachedSessionInfo,
+    getCachedSessionInfo,
+    getSessionDetails,
+} from './sessionInfoService';
+
+describe('sessionInfoService', () => {
+    beforeEach(() => {
+        resetCachedPreauthInfo();
+        resetCachedSessionInfo();
+        jest.clearAllMocks();
+    });
+
+    describe('formatPreauthInfo', () => {
+        it('parses headers and JSON body from a response', async () => {
+            const headers = new Headers({ 'content-type': 'application/json' });
+            const mockResp = {
+                headers,
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'u1' } }),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result.info.userGUID).toBe('u1');
+            expect(result.status).toBe(200);
+            expect(result.headers['content-type']).toBe('application/json');
+        });
+
+        it('returns null when response.json() throws (covers catch block)', async () => {
+            const mockResp = {
+                headers: null as any,
+                json: jest.fn().mockRejectedValue(new Error('parse error')),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result).toBeNull();
+        });
+
+        it('handles response where headers is null (covers headers?.forEach branch)', async () => {
+            const mockResp = {
+                headers: null as any,
+                json: jest.fn().mockResolvedValue({ info: {} }),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result.headers).toEqual({});
+        });
+    });
+
+    describe('getPreauthInfo', () => {
+        it('fetches and caches preauthInfo on first call', async () => {
+            const mockResp = {
+                headers: new Headers({ 'x-caller': 'test' }),
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'u1' } }),
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockResolvedValue(mockResp as any);
+
+            const result = await getPreauthInfo();
+            expect(result.info.userGUID).toBe('u1');
+        });
+
+        it('returns cached preauthInfo on subsequent calls (covers allowCache=true && preauthInfo cached branch)', async () => {
+            const mockResp = {
+                headers: new Headers(),
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'cached-user' } }),
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            const fetchSpy = jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockResolvedValue(mockResp as any);
+
+            await getPreauthInfo(); // first call — fetches and caches
+            await getPreauthInfo(); // second call — should use cache
+
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+        });
+
+        it('returns null when fetch throws (covers catch block)', async () => {
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockRejectedValue(new Error('network error'));
+
+            const result = await getPreauthInfo();
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getSessionInfo', () => {
+        it('fetches and returns session info', async () => {
+            const sessionInfoResp = {
+                userGUID: 'u1',
+                releaseVersion: '1.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev', prodSdkKey: 'prod', production: false },
+                    isPublicUser: false,
+                    selfClusterId: 'c1',
+                    selfClusterName: 'cluster1',
+                },
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchSessionInfoService').mockResolvedValue(sessionInfoResp as any);
+
+            const result = await getSessionInfo();
+            expect(result.userGUID).toBe('u1');
+            expect(result.mixpanelToken).toBe('dev');
+        });
+
+        it('returns cached session info on second call', async () => {
+            const sessionInfoResp = {
+                userGUID: 'u2',
+                releaseVersion: '2.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev2', prodSdkKey: 'prod2', production: true },
+                    isPublicUser: false,
+                    selfClusterId: 'c2',
+                    selfClusterName: 'cluster2',
+                },
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            const fetchSpy = jest.spyOn(authServiceModule, 'fetchSessionInfoService').mockResolvedValue(sessionInfoResp as any);
+
+            await getSessionInfo();
+            await getSessionInfo();
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('getCachedSessionInfo', () => {
+        it('returns null before any fetch', () => {
+            expect(getCachedSessionInfo()).toBeNull();
+        });
+    });
+
+    describe('getSessionDetails', () => {
+        it('uses prodSdkKey when production flag is true', () => {
+            const resp = {
+                userGUID: 'u3',
+                releaseVersion: '3.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev', prodSdkKey: 'prod', production: true },
+                    isPublicUser: true,
+                    selfClusterId: 'c3',
+                    selfClusterName: 'cluster3',
+                },
+            };
+            const result = getSessionDetails(resp);
+            expect(result.mixpanelToken).toBe('prod');
+            expect(result.isPublicUser).toBe(true);
+        });
+    });
+});

package/src/utils.spec.ts

@@ -27,6 +27,13 @@ import {
     validateHttpUrl,
     setParamIfDefined,
     querySelectorAcrossShadowRoot,
+    getSSOMarker,
+    deepMerge,
+    getHostEventsConfig,
+    isWindowUndefined,
+    getOffsetTop,
+    getDOMNode,
+    getOperationNameFromQuery,
 } from './utils';
 import { RuntimeFilterOp } from './types';
 import { logger } from './utils/logger';
@@ -388,6 +395,18 @@ describe('Fullscreen Utility Functions', () => {
             expect(logger.error).toHaveBeenCalledWith('Fullscreen API is not supported by this browser.');
         });
 
+        it('should catch error and log warning when requestFullscreen throws (covers line 506)', async () => {
+            // Covers line 506: catch block inside fullscreen method attempt
+            (mockIframe.requestFullscreen as jest.Mock).mockRejectedValue(new Error('permission denied'));
+
+            await handlePresentEvent(mockIframe);
+
+            expect(logger.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to enter fullscreen'),
+                expect.any(Error),
+            );
+        });
+
         it('should not attempt fullscreen when already in fullscreen mode', () => {
             Object.defineProperty(document, 'fullscreenElement', {
                 writable: true,
@@ -1009,6 +1028,24 @@ describe('isValidCssMargin', () => {
         expect(isValidCssMargin('invalid')).toBe(false);
         expect(isValidCssMargin('10')).toBe(false); // missing unit
     });
+
+    it('should return false and log error when value is not a string (non-string type)', () => {
+        // Covers line 147-148: typeof value !== 'string' branch
+        expect(isValidCssMargin(42 as any)).toBe(false);
+        expect(logger.error).toHaveBeenCalledWith('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+    });
+
+    it('should return false when more than 4 space-separated parts are given', () => {
+        // Covers line 157-158: parts.length > 4 branch
+        expect(isValidCssMargin('10px 20px 30px 40px 50px')).toBe(false);
+        expect(logger.error).toHaveBeenCalledWith('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+    });
+
+    it('should return true for valid multi-part margin (up to 4 parts)', () => {
+        expect(isValidCssMargin('10px 20px')).toBe(true);
+        expect(isValidCssMargin('10px 20px 30px 40px')).toBe(true);
+        expect(isValidCssMargin('auto')).toBe(true);
+    });
 });
 
 describe('getValueFromWindow and storeValueInWindow', () => {
@@ -1140,3 +1177,161 @@ describe('getValueFromWindow and storeValueInWindow', () => {
         });
     });
 });
+
+// ---------------------------------------------------------------------------
+// getSSOMarker
+// ---------------------------------------------------------------------------
+describe('getSSOMarker', () => {
+    test('returns tsSSOMarker query string with encoded markerId', () => {
+        expect(getSSOMarker('abc123')).toBe('tsSSOMarker=abc123');
+    });
+
+    test('URL-encodes special characters in markerId', () => {
+        expect(getSSOMarker('hello world')).toBe('tsSSOMarker=hello%20world');
+        expect(getSSOMarker('foo=bar&baz')).toBe('tsSSOMarker=foo%3Dbar%26baz');
+    });
+
+    test('handles empty string markerId', () => {
+        expect(getSSOMarker('')).toBe('tsSSOMarker=');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// deepMerge
+// ---------------------------------------------------------------------------
+describe('deepMerge', () => {
+    test('merges two flat objects', () => {
+        const result = deepMerge({ a: 1 }, { b: 2 });
+        expect(result).toEqual({ a: 1, b: 2 });
+    });
+
+    test('source overrides target for same keys', () => {
+        const result = deepMerge({ a: 1, b: 2 }, { b: 99 });
+        expect(result).toEqual({ a: 1, b: 99 });
+    });
+
+    test('deep merges nested objects', () => {
+        const result = deepMerge({ a: { x: 1, y: 2 } }, { a: { y: 99, z: 3 } });
+        expect(result).toEqual({ a: { x: 1, y: 99, z: 3 } });
+    });
+
+    test('handles empty source', () => {
+        const result = deepMerge({ a: 1 }, {});
+        expect(result).toEqual({ a: 1 });
+    });
+
+    test('handles empty target', () => {
+        const result = deepMerge({}, { b: 2 });
+        expect(result).toEqual({ b: 2 });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getHostEventsConfig
+// ---------------------------------------------------------------------------
+describe('getHostEventsConfig', () => {
+    test('returns shouldBypassPayloadValidation and useHostEventsV2 from viewConfig', () => {
+        const viewConfig: any = { shouldBypassPayloadValidation: true, useHostEventsV2: false };
+        expect(getHostEventsConfig(viewConfig)).toEqual({
+            shouldBypassPayloadValidation: true,
+            useHostEventsV2: false,
+        });
+    });
+
+    test('returns undefined for missing keys', () => {
+        const result = getHostEventsConfig({} as any);
+        expect(result.shouldBypassPayloadValidation).toBeUndefined();
+        expect(result.useHostEventsV2).toBeUndefined();
+    });
+
+    test('ignores unrelated config properties', () => {
+        const viewConfig: any = {
+            shouldBypassPayloadValidation: false,
+            useHostEventsV2: true,
+            liveboardId: 'lb-1',
+        };
+        expect(getHostEventsConfig(viewConfig)).toEqual({
+            shouldBypassPayloadValidation: false,
+            useHostEventsV2: true,
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// isWindowUndefined
+// ---------------------------------------------------------------------------
+describe('isWindowUndefined', () => {
+    test('returns false when window is defined (browser/jsdom env)', () => {
+        // In jest/jsdom, window is always defined
+        expect(isWindowUndefined()).toBe(false);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getOffsetTop
+// ---------------------------------------------------------------------------
+describe('getOffsetTop', () => {
+    test('returns rect.top + window.scrollY', () => {
+        const mockElement = {
+            getBoundingClientRect: () => ({ top: 50 }),
+        };
+        Object.defineProperty(window, 'scrollY', { value: 100, configurable: true });
+        expect(getOffsetTop(mockElement)).toBe(150);
+    });
+
+    test('returns rect.top when scrollY is 0', () => {
+        const mockElement = {
+            getBoundingClientRect: () => ({ top: 30 }),
+        };
+        Object.defineProperty(window, 'scrollY', { value: 0, configurable: true });
+        expect(getOffsetTop(mockElement)).toBe(30);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getDOMNode
+// ---------------------------------------------------------------------------
+describe('getDOMNode', () => {
+    test('returns the element from document.querySelector when passed a string selector', () => {
+        const div = document.createElement('div');
+        div.id = 'test-dom-node';
+        document.body.appendChild(div);
+        expect(getDOMNode('#test-dom-node')).toBe(div);
+        document.body.removeChild(div);
+    });
+
+    test('returns the element directly when passed an HTMLElement', () => {
+        const div = document.createElement('div');
+        expect(getDOMNode(div)).toBe(div);
+    });
+
+    test('returns null for a selector that matches nothing', () => {
+        expect(getDOMNode('#nonexistent-element-xyz')).toBeNull();
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getOperationNameFromQuery
+// ---------------------------------------------------------------------------
+describe('getOperationNameFromQuery', () => {
+    test('extracts operation name from a query string', () => {
+        expect(getOperationNameFromQuery('query GetUser { user { id } }')).toBe('GetUser');
+    });
+
+    test('extracts operation name from a mutation string', () => {
+        expect(getOperationNameFromQuery('mutation CreateUser { createUser { id } }')).toBe('CreateUser');
+    });
+
+    test('returns undefined when no operation name is present', () => {
+        expect(getOperationNameFromQuery('{ user { id } }')).toBeUndefined();
+    });
+
+    test('handles multiline query strings', () => {
+        const query = `
+            query FetchData {
+                data { id }
+            }
+        `;
+        expect(getOperationNameFromQuery(query)).toBe('FetchData');
+    });
+});