@thoughtspot/visual-embed-sdk 1.44.1 → 1.44.3

package/src/utils/graphql/graphql-request.spec.ts

@@ -20,7 +20,7 @@ describe('graphQl tests', () => {
             json: jest.fn().mockResolvedValue({
                 data: {},
             }),
-        });
+        } as any);
 
         const details = await graphqlQuery({
             query: getSourceDetailQuery,
@@ -30,7 +30,7 @@ describe('graphQl tests', () => {
             thoughtSpotHost,
         });
 
-        expect(tokenizedFetchUtil.tokenizedFetch).toBeCalledWith('TSHOST/prism/?op=GetSourceDetail', {
+        expect(tokenizedFetchUtil.tokenizedFetch).toHaveBeenCalledWith('TSHOST/prism/?op=GetSourceDetail', {
             body: '{"operationName":"GetSourceDetail","query":"\\n    query GetSourceDetail($ids: [GUID!]!) {\\n        getSourceDetailById(ids: $ids, type: LOGICAL_TABLE) {\\n            id\\n            name\\n        }\\n    }  \\n","variables":{"ids":[2]}}',
             credentials: 'include',
             headers: {

package/src/utils/graphql/sourceService.spec.ts

@@ -14,6 +14,6 @@ describe('Source service tests', () => {
         }));
         await getSourceDetail('https://tshost', 'id');
         await getSourceDetail('https://tshost', 'id');
-        expect(fetchMock).toBeCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
     });
 });

package/src/utils/processData.spec.ts

@@ -10,7 +10,7 @@ import { logger } from './logger';
 
 describe('Unit test for process data', () => {
     beforeAll(() => {
-        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
+        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve(undefined));
         base.init({
             thoughtSpotHost: 'https://tshost',
             authType: AuthType.None,
@@ -84,7 +84,7 @@ describe('Unit test for process data', () => {
         const processedData = { type: EmbedEvent.Data };
         jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
         processDataInstance.processEventData(EmbedEvent.Data, processedData, thoughtSpotHost, null);
-        expect(processDataInstance.processCustomAction).not.toBeCalled();
+        expect(processDataInstance.processCustomAction).not.toHaveBeenCalled();
     });
 
     test('AuthInit', () => {
@@ -95,14 +95,14 @@ describe('Unit test for process data', () => {
         };
         const e = { type: EmbedEvent.AuthInit, data: sessionInfo };
         jest.spyOn(base, 'notifyAuthSuccess');
-        jest.spyOn(sessionInfoService, 'getSessionInfo').mockReturnValue(sessionInfo);
+        jest.spyOn(sessionInfoService, 'getSessionInfo').mockImplementation(() => Promise.resolve(sessionInfo as any));
         expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
             type: e.type,
             data: {
                 userGUID: sessionInfo.userGUID,
             },
         });
-        expect(base.notifyAuthSuccess).toBeCalled();
+        expect(base.notifyAuthSuccess).toHaveBeenCalled();
     });
 
     test('NoCookieAccess no suppress alert', () => {
@@ -111,14 +111,14 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             suppressNoCookieAccessAlert: false,
-        });
+        } as any);
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
-        expect(window.alert).toBeCalled();
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(window.alert).toHaveBeenCalled();
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -128,15 +128,15 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             suppressNoCookieAccessAlert: true,
-        });
+        } as any);
         jest.spyOn(window, 'alert').mockReset();
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
-        expect(window.alert).not.toBeCalled();
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(window.alert).not.toHaveBeenCalled();
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -146,15 +146,15 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             ignoreNoCookieAccess: true,
-        });
+        } as any);
         jest.spyOn(window, 'alert').mockReset();
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
-        expect(window.alert).not.toBeCalled();
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(window.alert).not.toHaveBeenCalled();
         expect(el.innerHTML).not.toBe('Hello');
     });
 
@@ -163,12 +163,12 @@ describe('Unit test for process data', () => {
         jest.spyOn(base, 'notifyAuthFailure');
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.OTHER);
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.OTHER);
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -178,12 +178,12 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             authType: AuthType.None,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).not.toBeCalled();
+        expect(base.notifyAuthFailure).not.toHaveBeenCalled();
         expect(el.innerHTML).not.toBe('Hello');
     });
 
@@ -201,7 +201,7 @@ describe('Unit test for process data', () => {
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyLogout).toBeCalled();
+        expect(base.notifyLogout).toHaveBeenCalled();
         expect(el.innerHTML).toBe('Hello');
         expect(embedConfigInstance.getEmbedConfig().autoLogin).toBe(false);
     });
@@ -212,12 +212,12 @@ describe('Unit test for process data', () => {
             loginFailedMessage: 'Hello',
             authType: AuthType.EmbeddedSSO,
             disableLoginFailurePage: true,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).not.toBeCalled();
+        expect(base.notifyAuthFailure).not.toHaveBeenCalled();
         expect(el.innerHTML).not.toBe('Hello');
     });
 
@@ -228,12 +228,12 @@ describe('Unit test for process data', () => {
             loginFailedMessage: 'Hello',
             authType: AuthType.TrustedAuthToken,
             autoLogin: true,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -244,12 +244,12 @@ describe('Unit test for process data', () => {
             loginFailedMessage: 'Hello',
             authType: AuthType.TrustedAuthTokenCookieless,
             autoLogin: true,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -258,9 +258,9 @@ describe('Unit test for process data', () => {
             disableFullscreenPresentation: false,
         };
         
-        const mockHandleExitPresentMode = jest.spyOn(utilsModule, 'handleExitPresentMode').mockImplementation(() => {});
+        const mockHandleExitPresentMode = jest.spyOn(utilsModule, 'handleExitPresentMode').mockImplementation(() => Promise.resolve(undefined));
         
-        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue(mockConfig);
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue(mockConfig as any);
 
         const processedData = {
             type: EmbedEvent.ExitPresentMode,

package/src/utils/processTrigger.spec.ts

@@ -29,7 +29,7 @@ describe('Unit test for processTrigger', () => {
         const data = {};
         _processTriggerInstance.processTrigger(iFrameElement, messageType, thoughtSpotHost, data);
         jest.advanceTimersByTime(200);
-        expect(spyReload).toBeCalledWith(iFrameElement);
+        expect(spyReload).toHaveBeenCalledWith(iFrameElement);
     });
 
     test('when hostevent is search, postMessage should be called', async () => {
@@ -43,14 +43,14 @@ describe('Unit test for processTrigger', () => {
             thoughtSpotHost,
             data,
         );
-        expect(iFrame.contentWindow.postMessage).toBeCalled();
+        expect(iFrame.contentWindow.postMessage).toHaveBeenCalled();
         const res = {
             data: {
                 test: '123',
             },
         };
         messageChannelMock.port1.onmessage(res);
-        expect(messageChannelMock.port1.close).toBeCalled();
+        expect(messageChannelMock.port1.close).toHaveBeenCalled();
         expect(triggerPromise).resolves.toEqual(res.data);
     });
 
@@ -65,14 +65,14 @@ describe('Unit test for processTrigger', () => {
             thoughtSpotHost,
             data,
         );
-        expect(iFrame.contentWindow.postMessage).toBeCalled();
+        expect(iFrame.contentWindow.postMessage).toHaveBeenCalled();
         const res = {
             data: {
                 error: 'error',
             },
         };
         messageChannelMock.port1.onmessage(res);
-        expect(messageChannelMock.port1.close).toBeCalled();
+        expect(messageChannelMock.port1.close).toHaveBeenCalled();
         expect(triggerPromise).rejects.toEqual(res.data.error);
     });
 
@@ -91,7 +91,7 @@ describe('Unit test for processTrigger', () => {
 
         jest.advanceTimersByTime(_processTriggerInstance.TRIGGER_TIMEOUT);
 
-        expect(messageChannelMock.port1.close).toBeCalled();
+        expect(messageChannelMock.port1.close).toHaveBeenCalled();
         await expect(triggerPromise).resolves.toBeInstanceOf(Error);
     });
 
@@ -101,9 +101,9 @@ describe('Unit test for processTrigger', () => {
         let mockGetEmbedConfig: any;
 
         beforeEach(() => {
-            mockHandlePresentEvent = jest.spyOn(utilsModule, 'handlePresentEvent').mockImplementation(() => {});
+            mockHandlePresentEvent = jest.spyOn(utilsModule, 'handlePresentEvent').mockImplementation(() => Promise.resolve(undefined));
             mockLoggerWarn = jest.spyOn(logger, 'warn').mockImplementation(() => {});
-            mockGetEmbedConfig = jest.spyOn(embedConfigModule, 'getEmbedConfig').mockImplementation(() => ({}));
+            mockGetEmbedConfig = jest.spyOn(embedConfigModule, 'getEmbedConfig').mockImplementation(() => ({ disableFullscreenPresentation: false } as any));
         });
 
         afterEach(() => {

package/src/utils.spec.ts

@@ -19,9 +19,12 @@ import {
     arrayIncludesString,
     calculateVisibleElementData,
     formatTemplate,
+    isValidCssMargin,
+    resetValueFromWindow,
 } from './utils';
 import { RuntimeFilterOp } from './types';
 import { logger } from './utils/logger';
+import { ERROR_MESSAGE } from './errors';
 
 // Mock logger
 jest.mock('./utils/logger', () => ({
@@ -142,12 +145,12 @@ describe('unit test for utils', () => {
     });
 
     describe('getRedirectURL', () => {
-        let windowSpy: any;
+        let originalLocation: Location;
         beforeEach(() => {
-            windowSpy = jest.spyOn(window, 'window', 'get');
+            originalLocation = window.location;
         });
         afterEach(() => {
-            windowSpy.mockRestore();
+            window.location.hash = '';
         });
 
         test('Should return correct value when path is undefined', () => {
@@ -158,18 +161,12 @@ describe('unit test for utils', () => {
         });
 
         test('Should return correct value when path is set', () => {
-            windowSpy.mockImplementation(() => ({
-                location: {
-                    origin: 'http://myhost:3000',
-                },
-            }));
-
             expect(getRedirectUrl('http://myhost:3000/', 'hashFrag', '/bar')).toBe(
-                'http://myhost:3000/bar#?tsSSOMarker=hashFrag',
+                'http://localhost/bar#?tsSSOMarker=hashFrag',
             );
 
             expect(getRedirectUrl('http://myhost:3000/#/foo', 'hashFrag', '#/bar')).toBe(
-                'http://myhost:3000/#/bar?tsSSOMarker=hashFrag',
+                'http://localhost/#/bar?tsSSOMarker=hashFrag',
             );
         });
     });
@@ -736,3 +733,95 @@ describe('formatTemplate', () => {
         ).toBe('Hello John, you are {age} years old');
     });
 });
+
+describe('isValidCssMargin', () => {
+    it('should return true for valid CSS margin values', () => {
+        expect(isValidCssMargin('10px')).toBe(true);
+        expect(isValidCssMargin('0px')).toBe(true);
+        expect(isValidCssMargin('20%')).toBe(true);
+        expect(isValidCssMargin('0')).toBe(true);
+    });
+
+    it('should return false for invalid CSS margin values', () => {
+        expect(isValidCssMargin('')).toBe(false);
+        expect(isValidCssMargin('   ')).toBe(false);
+        expect(isValidCssMargin('invalid')).toBe(false);
+        expect(isValidCssMargin('10')).toBe(false); // missing unit
+    });
+});
+
+describe('getValueFromWindow and storeValueInWindow', () => {
+    describe('SSR environment handling', () => {
+        let originalWindow: typeof globalThis.window;
+        beforeEach(() => {
+            originalWindow = global.window;
+        });
+
+        afterEach(() => {
+            global.window = originalWindow;
+        });
+
+        test('storeValueInWindow should log error in SSR environment', () => {
+            delete global.window;
+            
+            const result = storeValueInWindow('testKey', 'testValue');
+            
+            expect(logger.error).toHaveBeenCalledWith(
+                ERROR_MESSAGE.SSR_ENVIRONMENT_ERROR
+            );
+            expect(result).toBe('testValue');
+        });
+
+        test('getValueFromWindow should log error in SSR environment', () => {
+            delete global.window;
+            
+            const result = getValueFromWindow('testKey');
+            
+            expect(logger.error).toHaveBeenCalledWith(
+                ERROR_MESSAGE.SSR_ENVIRONMENT_ERROR
+            );
+            expect(result).toBeUndefined();
+        });
+
+        test('resetValueFromWindow should log error in SSR environment', () => {
+            delete global.window;
+            
+            const result = resetValueFromWindow('testKey');
+            
+            expect(logger.error).toHaveBeenCalledWith(
+                ERROR_MESSAGE.SSR_ENVIRONMENT_ERROR
+            );
+            expect(result).toBe(false);
+        });
+    });
+    describe('resetValueFromWindow', () => {
+        beforeEach(() => {
+            (window as any)._tsEmbedSDK = {};
+        });
+
+        test('should reset existing key and return true', () => {
+            storeValueInWindow('keyToReset', 'someValue');
+            expect(getValueFromWindow('keyToReset')).toBe('someValue');
+
+            const result = resetValueFromWindow('keyToReset');
+
+            expect(result).toBe(true);
+            expect(getValueFromWindow('keyToReset')).toBe(undefined);
+        });
+
+        test('should return false when key does not exist', () => {
+            const result = resetValueFromWindow('nonExistentKey');
+            expect(result).toBe(false);
+        });
+
+        test('should only reset the specified key', () => {
+            storeValueInWindow('key1', 'value1');
+            storeValueInWindow('key2', 'value2');
+
+            resetValueFromWindow('key1');
+
+            expect(getValueFromWindow('key1')).toBe(undefined);
+            expect(getValueFromWindow('key2')).toBe('value2');
+        });
+    });
+});

package/src/utils.ts

@@ -17,6 +17,7 @@ import {
     AllEmbedViewConfig,
 } from './types';
 import { logger } from './utils/logger';
+import { ERROR_MESSAGE } from './errors';
 
 /**
  * Construct a runtime filters query string from the given filters.
@@ -132,6 +133,40 @@ export const getCssDimension = (value: number | string): string => {
     return value;
 };
 
+/**
+ * Validates if a string is a valid CSS margin value.
+ * @param value - The string to validate
+ * @returns true if the value is a valid CSS margin value, false otherwise
+ */
+export const isValidCssMargin = (value: string): boolean => {
+    if(isUndefined(value)) {
+        return false;
+    }
+    if (typeof value !== 'string') {
+        logger.error('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+        return false;
+    }
+
+    // This pattern allows for an optional negative sign, and numbers that can be integers or decimals (including leading dot).
+    const cssUnitPattern = /^-?(\d+(\.\d*)?|\.\d+)(px|em|rem|%|vh|vw)$/i;
+    const parts = value.trim().split(/\s+/);
+
+    if (parts.length > 4) {
+        logger.error('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+        return false;
+    }
+
+    const isValid = parts.every(part => {
+        const trimmedPart = part.trim();
+        return trimmedPart.toLowerCase() === 'auto' || trimmedPart === '0' || cssUnitPattern.test(trimmedPart);
+    });
+    if (!isValid) {
+        logger.error('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+        return false;
+    }
+    return true;
+};
+
 export const getSSOMarker = (markerId: string) => {
     const encStringToAppend = encodeURIComponent(markerId);
     return `tsSSOMarker=${encStringToAppend}`;
@@ -359,6 +394,7 @@ export function storeValueInWindow<T>(
     value: T,
     options: { ignoreIfAlreadyExists?: boolean } = {},
 ): T {
+    if (isWindowUndefined()) return value;
     if (!window[sdkWindowKey]) {
         (window as any)[sdkWindowKey] = {};
     }
@@ -372,13 +408,14 @@ export function storeValueInWindow<T>(
 }
 
 /**
- * Retrieves a stored value from the global `window` object under the `_tsEmbedSDK` namespace.
- * @param key - The key whose value needs to be retrieved.
- * @returns The stored value or `undefined` if the key is not found.
+ * Retrieves a stored value from the global 
+ * `window` object under the `_tsEmbedSDK` namespace.
+ * Returns undefined in SSR environment.
  */
-export const getValueFromWindow = <T = any>
-    (key: string): T => (window as any)?.[sdkWindowKey]?.[key];
-
+export const getValueFromWindow = <T = any>(key: string): T | undefined => {
+    if (isWindowUndefined()) return undefined;
+    return (window as any)?.[sdkWindowKey]?.[key];
+};
 /**
  * Check if an array includes a string value
  * @param arr - The array to check
@@ -396,6 +433,7 @@ export const arrayIncludesString = (arr: readonly unknown[], key: string): boole
  * @returns - boolean indicating if the key was reset
  */
 export function resetValueFromWindow(key: string): boolean {
+    if (isWindowUndefined()) return false;
     if (key in window[sdkWindowKey]) {
         delete (window as any)[sdkWindowKey][key];
         return true;
@@ -519,4 +557,18 @@ export const formatTemplate = (template: string, values: Record<string, any>): s
     return template.replace(/\{(\w+)\}/g, (match, key) => {
         return values[key] !== undefined ? String(values[key]) : match;
     });
-};
+};
+
+/**
+ * Check if the window is undefined
+ * If the window is undefined, it means the code is running in a SSR environment.
+ * @returns true if the window is undefined, false otherwise
+ * 
+ */
+export const isWindowUndefined = (): boolean => {
+    if(typeof window === 'undefined') {
+        logger.error(ERROR_MESSAGE.SSR_ENVIRONMENT_ERROR);
+        return true;
+    }
+    return false;
+}