@thoughtspot/visual-embed-sdk 1.45.1 → 1.45.3

package/src/utils/processTrigger.ts

@@ -1,5 +1,5 @@
 import { ERROR_MESSAGE } from '../errors';
-import { HostEvent, MessagePayload } from '../types';
+import { ContextType, HostEvent, MessagePayload } from '../types';
 import { logger } from '../utils/logger';
 import { handlePresentEvent } from '../utils';
 import { getEmbedConfig } from '../embed/embedConfig';
@@ -22,12 +22,13 @@ export const reload = (iFrame: HTMLIFrameElement) => {
  * @param message
  * @param message.type
  * @param message.data
+ * @param message.context
  * @param thoughtSpotHost
  * @param channel
  */
 function postIframeMessage(
     iFrame: HTMLIFrameElement,
-    message: { type: HostEvent; data: any },
+    message: { type: HostEvent; data: any, context?: any },
     thoughtSpotHost: string,
     channel?: MessageChannel,
 ) {
@@ -42,12 +43,14 @@ export const TRIGGER_TIMEOUT = 30000;
  * @param messageType
  * @param thoughtSpotHost
  * @param data
+ * @param context
  */
 export function processTrigger(
     iFrame: HTMLIFrameElement,
     messageType: HostEvent,
     thoughtSpotHost: string,
     data: any,
+    context?: ContextType,
 ): Promise<any> {
     return new Promise<any>((res, rej) => {
         if (messageType === HostEvent.Reload) {
@@ -83,6 +86,6 @@ export function processTrigger(
             res(new Error(ERROR_MESSAGE.TRIGGER_TIMED_OUT));
         }, TRIGGER_TIMEOUT);
 
-        return postIframeMessage(iFrame, { type: messageType, data }, thoughtSpotHost, channel);
+        return postIframeMessage(iFrame, { type: messageType, data, context }, thoughtSpotHost, channel);
     });
 }

package/src/utils.spec.ts

@@ -21,6 +21,8 @@ import {
     formatTemplate,
     isValidCssMargin,
     resetValueFromWindow,
+    validateHttpUrl,
+    setParamIfDefined,
 } from './utils';
 import { RuntimeFilterOp } from './types';
 import { logger } from './utils/logger';
@@ -824,4 +826,58 @@ describe('getValueFromWindow and storeValueInWindow', () => {
             expect(getValueFromWindow('key2')).toBe('value2');
         });
     });
+
+    describe('validateHttpUrl', () => {
+        test.each([
+            ['http URL', 'http://example.com'],
+            ['https URL', 'https://example.com'],
+            ['https URL with path', 'https://docs.example.com/spotter'],
+            ['https URL with query params', 'https://example.com/path?foo=bar'],
+        ])('should return [true, null] for valid %s', (_, url) => {
+            const [isValid, error] = validateHttpUrl(url);
+            expect(isValid).toBe(true);
+            expect(error).toBeNull();
+        });
+
+        test.each([
+            ['ftp protocol', 'ftp://example.com', 'ftp:'],
+            ['file protocol', 'file:///path/to/file', 'file:'],
+            ['javascript protocol', 'javascript:alert(1)', 'javascript:'],
+        ])('should return [false, Error] for %s', (_, url, protocol) => {
+            const [isValid, error] = validateHttpUrl(url);
+            expect(isValid).toBe(false);
+            expect(error).toBeInstanceOf(Error);
+            expect(error?.message).toContain('Invalid protocol');
+            expect(error?.message).toContain(protocol);
+        });
+
+        test.each([
+            ['invalid URL format', 'not-a-valid-url'],
+            ['empty string', ''],
+            ['URL without protocol', 'example.com'],
+        ])('should return [false, Error] for %s', (_, url) => {
+            const [isValid, error] = validateHttpUrl(url);
+            expect(isValid).toBe(false);
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+
+    describe('setParamIfDefined', () => {
+        test.each([
+            ['string value', 'testParam', 'testValue', false, 'testValue'],
+            ['number value', 'numParam', 42, false, 42],
+            ['truthy value as boolean', 'boolParam', 'truthy', true, true],
+            ['falsy value as boolean', 'boolParam', 0, true, false],
+        ])('should set %s correctly', (_, param, value, asBoolean, expected) => {
+            const queryParams: Record<string, unknown> = {};
+            setParamIfDefined(queryParams, param, value, asBoolean);
+            expect(queryParams[param]).toBe(expected);
+        });
+
+        test('should not set param when value is undefined', () => {
+            const queryParams: Record<string, unknown> = {};
+            setParamIfDefined(queryParams, 'testParam', undefined);
+            expect(queryParams.testParam).toBeUndefined();
+        });
+    });
 });

package/src/utils.ts

@@ -15,6 +15,7 @@ import {
     DOMSelector,
     RuntimeParameter,
     AllEmbedViewConfig,
+    BaseViewConfig,
 } from './types';
 import { logger } from './utils/logger';
 import { ERROR_MESSAGE } from './errors';
@@ -560,6 +561,13 @@ export const formatTemplate = (template: string, values: Record<string, any>): s
     });
 };
 
+export const getHostEventsConfig = (viewConfig: BaseViewConfig) => {
+    return {
+        shouldBypassPayloadValidation: viewConfig.shouldBypassPayloadValidation,
+        useHostEventsV2: viewConfig.useHostEventsV2,
+    };
+}
+
 /**
  * Check if the window is undefined
  * If the window is undefined, it means the code is running in a SSR environment.
@@ -573,3 +581,39 @@ export const isWindowUndefined = (): boolean => {
     }
     return false;
 }
+
+/**
+ * Validates that a URL uses only http: or https: protocols.
+ * Returns a tuple of [isValid, error] so the caller can handle validation errors.
+ * @param url - The URL string to validate
+ * @returns [true, null] if valid, [false, Error] if invalid
+ */
+export const validateHttpUrl = (url: string): [boolean, Error | null] => {
+    try {
+        const parsedUrl = new URL(url);
+        if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+            return [false, new Error(`Invalid protocol: ${parsedUrl.protocol}. Only http: and https: are allowed.`)];
+        }
+        return [true, null];
+    } catch (error) {
+        return [false, error instanceof Error ? error : new Error(String(error))];
+    }
+};
+
+/**
+ * Sets a query parameter if the value is defined.
+ * @param queryParams - The query params object to modify
+ * @param param - The parameter key
+ * @param value - The value to set
+ * @param asBoolean - If true, coerces value to boolean
+ */
+export const setParamIfDefined = <T>(
+    queryParams: Record<string, unknown>,
+    param: string,
+    value: T | undefined,
+    asBoolean = false,
+): void => {
+    if (value !== undefined) {
+        queryParams[param] = asBoolean ? !!value : value;
+    }
+};