@thoughtspot/visual-embed-sdk 1.42.3 → 1.43.1

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

@@ -19,8 +19,10 @@ import { processTrigger } from '../utils/processTrigger';
 import { UIPassthroughEvent } from './hostEventClient/contracts';
 import * as sessionInfoService from '../utils/sessionInfoService';
 import * as authToken from '../authToken';
+import * as apiIntercept from '../api-intercept';
 jest.mock('../utils/processTrigger');
 const mockProcessTrigger = processTrigger;
+const mockHandleInterceptEvent = jest.spyOn(apiIntercept, 'handleInterceptEvent');
 const defaultViewConfig = {
     frameParams: {
         width: 1280,
@@ -60,6 +62,30 @@ const customVariablesForThirdPartyTools = {
     key1: '!@#',
     key2: '*%^',
 };
+const getMockAppInitPayload = (data) => {
+    const defaultData = {
+        customisations,
+        authToken: '',
+        hostConfig: undefined,
+        runtimeFilterParams: null,
+        runtimeParameterParams: null,
+        hiddenHomeLeftNavItems: [],
+        hiddenHomepageModules: [],
+        hiddenListColumns: [],
+        customActions: [],
+        reorderedHomepageModules: [],
+        customVariablesForThirdPartyTools,
+        interceptTimeout: undefined,
+        interceptUrls: [],
+    };
+    return {
+        type: EmbedEvent.APP_INIT,
+        data: {
+            ...defaultData,
+            ...data,
+        },
+    };
+};
 describe('Unit test case for ts embed', () => {
     const mockMixPanelEvent = jest.spyOn(mixpanelInstance, 'uploadMixpanelEvent');
     beforeEach(() => {
@@ -243,22 +269,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({}));
             });
         });
         test('verify Customisations from viewConfig', async () => {
@@ -279,22 +290,9 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations: customisationsView,
-                        authToken: '',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    customisations: customisationsView,
+                }));
             });
         });
         test('hide home page modules from view Config should be part of app_init payload', async () => {
@@ -319,22 +317,9 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        hostConfig: undefined,
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [HomepageModule.MyLibrary, HomepageModule.Learning],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    hiddenHomepageModules: [HomepageModule.MyLibrary, HomepageModule.Learning],
+                }));
             });
         });
         test('customVariablesForThirdPartyTools should be part of the app_init payload', async () => {
@@ -354,22 +339,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        hostConfig: undefined,
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({}));
             });
         });
         test('Reordering the home page modules from view Config should be part of app_init payload', async () => {
@@ -394,22 +364,9 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        hostConfig: undefined,
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        reorderedHomepageModules: [HomepageModule.MyLibrary, HomepageModule.Watchlist],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    reorderedHomepageModules: [HomepageModule.MyLibrary, HomepageModule.Watchlist],
+                }));
             });
         });
         test('Runtime parameters from view Config should be part of app_init payload when excludeRuntimeParametsfromURL is true', async () => {
@@ -437,22 +394,9 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: 'param1=color&paramVal1=blue',
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    runtimeParameterParams: 'param1=color&paramVal1=blue',
+                }));
             });
         });
         test('Runtime filters from view Config should be part of app_init payload when excludeRuntimeFiltersfromURL is true', async () => {
@@ -481,22 +425,9 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        runtimeFilterParams: 'col1=color&op1=EQ&val1=blue',
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    runtimeFilterParams: 'col1=color&op1=EQ&val1=blue',
+                }));
             });
         });
         test('Runtime filters from view Config should be not part of app_init payload when excludeRuntimeFiltersfromURL is undefined', async () => {
@@ -524,22 +455,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({}));
             });
         });
         test('Runtime filters from view Config should not be part of app_init payload when excludeRuntimeFiltersfromURL is false', async () => {
@@ -568,22 +484,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({}));
             });
         });
         test('homeLeftNav from view Config should be part of app_init payload', async () => {
@@ -608,22 +509,9 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        hostConfig: undefined,
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [HomeLeftNavItem.Home, HomeLeftNavItem.MonitorSubscription],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    hiddenHomeLeftNavItems: [HomeLeftNavItem.Home, HomeLeftNavItem.MonitorSubscription],
+                }));
             });
         });
         test('when Embed event status have start status', (done) => {
@@ -755,22 +643,10 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: 'test_auth_token1',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools: {},
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    authToken: 'test_auth_token1',
+                    customVariablesForThirdPartyTools: {},
+                }));
             });
             jest.spyOn(authService, 'verifyTokenService').mockClear();
         });
@@ -820,36 +696,25 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations: {
-                            content: {
-                                strings: {
-                                    Liveboard: 'Dashboard',
-                                },
-                                stringIDsUrl: 'https://sample-string-ids-url.com',
-                                stringIDs: {
-                                    'liveboard.header.title': 'Dashboard name',
-                                },
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    customisations: {
+                        content: {
+                            strings: {
+                                Liveboard: 'Dashboard',
                             },
-                            style: {
-                                customCSS: {},
-                                customCSSUrl: undefined,
+                            stringIDsUrl: 'https://sample-string-ids-url.com',
+                            stringIDs: {
+                                'liveboard.header.title': 'Dashboard name',
                             },
                         },
-                        authToken: 'test_auth_token1',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools: {},
+                        style: {
+                            customCSS: {},
+                            customCSSUrl: undefined,
+                        },
                     },
-                });
+                    authToken: 'test_auth_token1',
+                    customVariablesForThirdPartyTools: {},
+                }));
                 const customisationContent = mockPort.postMessage.mock.calls[0][0].data.customisations.content;
                 expect(customisationContent.stringIDsUrl)
                     .toBe('https://sample-string-ids-url.com');
@@ -925,43 +790,33 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.APP_INIT,
-                    data: {
-                        customisations: {
-                            content: {},
-                            style: {
-                                customCSS: {},
-                                customCSSUrl: undefined,
-                            },
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    customisations: {
+                        content: {},
+                        style: {
+                            customCSS: {},
+                            customCSSUrl: undefined,
                         },
-                        authToken: 'test_auth_token1',
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [
-                            {
-                                id: 'action2',
-                                name: 'Another Valid Action',
-                                target: CustomActionTarget.VIZ,
-                                position: CustomActionsPosition.MENU,
-                                metadataIds: { vizIds: ['viz456'] }
-                            },
-                            {
-                                id: 'action1',
-                                name: 'Valid Action',
-                                target: CustomActionTarget.LIVEBOARD,
-                                position: CustomActionsPosition.PRIMARY,
-                                metadataIds: { liveboardIds: ['lb123'] }
-                            }
-                        ],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools: {},
                     },
-                });
+                    authToken: 'test_auth_token1',
+                    customActions: [
+                        {
+                            id: 'action2',
+                            name: 'Another Valid Action',
+                            target: CustomActionTarget.VIZ,
+                            position: CustomActionsPosition.MENU,
+                            metadataIds: { vizIds: ['viz456'] }
+                        },
+                        {
+                            id: 'action1',
+                            name: 'Valid Action',
+                            target: CustomActionTarget.LIVEBOARD,
+                            position: CustomActionsPosition.PRIMARY,
+                            metadataIds: { liveboardIds: ['lb123'] }
+                        }
+                    ],
+                    customVariablesForThirdPartyTools: {},
+                }));
                 // Verify that CustomActionsValidationResult structure is
                 // correct
                 const appInitData = mockPort.postMessage.mock.calls[0][0].data;
@@ -2905,7 +2760,7 @@ describe('Unit test case for ts embed', () => {
                 const triggerSpy = jest.spyOn(appEmbed, 'trigger').mockResolvedValue(null);
                 const removeChildSpy = jest.spyOn(Node.prototype, 'removeChild').mockImplementation(() => getRootEl());
                 appEmbed.destroy();
-                // Should be called immediately when waitForCleanupOnDestroy is true
+                // Should be called immediately when config is enabled
                 expect(triggerSpy).toHaveBeenCalledWith(HostEvent.DestroyEmbed);
                 // Wait for the timeout to complete
                 await new Promise(resolve => setTimeout(resolve, 1100));
@@ -2957,5 +2812,324 @@ describe('Unit test case for ts embed', () => {
             });
         });
     });
+    describe('handleApiInterceptEvent', () => {
+        beforeEach(() => {
+            document.body.innerHTML = getDocumentBody();
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+            });
+            jest.clearAllMocks();
+            mockHandleInterceptEvent.mockClear();
+        });
+        test('should call handleInterceptEvent with correct parameters', async () => {
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {
+                        method: 'POST',
+                        body: JSON.stringify({
+                            variables: {
+                                session: { sessionId: 'session-123' },
+                                contextBookId: 'viz-456'
+                            }
+                        })
+                    }
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(mockHandleInterceptEvent).toHaveBeenCalledTimes(1);
+                const call = mockHandleInterceptEvent.mock.calls[0][0];
+                expect(call.eventData).toEqual(mockEventData);
+                expect(call.executeEvent).toBeInstanceOf(Function);
+                expect(call.getUnsavedAnswerTml).toBeInstanceOf(Function);
+                expect(call.viewConfig).toMatchObject(defaultViewConfig);
+            });
+        });
+        test('should execute callbacks through executeEvent function', async () => {
+            let capturedExecuteEvent;
+            mockHandleInterceptEvent.mockImplementation((params) => {
+                capturedExecuteEvent = params.executeEvent;
+            });
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            const mockCallback = jest.fn();
+            searchEmbed.on(EmbedEvent.CustomAction, mockCallback);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(capturedExecuteEvent).toBeDefined();
+                // Simulate executeEvent being called by handleInterceptEvent
+                const testData = { test: 'data' };
+                capturedExecuteEvent(EmbedEvent.CustomAction, testData);
+                // executeEvent passes data as first param to callback
+                expect(mockCallback).toHaveBeenCalled();
+                expect(mockCallback.mock.calls[0][0]).toEqual(testData);
+            });
+        });
+        test('should call triggerUIPassThrough through getUnsavedAnswerTml function', async () => {
+            let capturedGetUnsavedAnswerTml;
+            mockHandleInterceptEvent.mockImplementation((params) => {
+                capturedGetUnsavedAnswerTml = params.getUnsavedAnswerTml;
+            });
+            const mockTmlResponse = { tml: 'test-tml-content' };
+            mockProcessTrigger.mockResolvedValue([{ value: mockTmlResponse }]);
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(async () => {
+                expect(capturedGetUnsavedAnswerTml).toBeDefined();
+                // Clear previous calls
+                mockProcessTrigger.mockClear();
+                // Simulate getUnsavedAnswerTml being called by
+                // handleInterceptEvent
+                const result = await capturedGetUnsavedAnswerTml({
+                    sessionId: 'session-123',
+                    vizId: 'viz-456'
+                });
+                expect(mockProcessTrigger).toHaveBeenCalled();
+                const callArgs = mockProcessTrigger.mock.calls[0];
+                // Verify UIPassthrough event is triggered with the right params
+                expect(callArgs[1]).toBe('UiPassthrough');
+                expect(callArgs[3]).toMatchObject({
+                    type: 'getUnsavedAnswerTML',
+                    parameters: {
+                        sessionId: 'session-123',
+                        vizId: 'viz-456'
+                    }
+                });
+                expect(result).toEqual(mockTmlResponse);
+            });
+        });
+        test('should pass viewConfig to handleInterceptEvent', async () => {
+            const customViewConfig = {
+                ...defaultViewConfig,
+                interceptUrls: ['/api/test'],
+                interceptTimeout: 5000,
+            };
+            const searchEmbed = new SearchEmbed(getRootEl(), customViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/api/test',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(() => {
+                const call = mockHandleInterceptEvent.mock.calls[0][0];
+                expect(call.viewConfig).toMatchObject({
+                    interceptUrls: ['/api/test'],
+                    interceptTimeout: 5000,
+                });
+            });
+        });
+        test('should handle ApiIntercept event with eventPort', async () => {
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(mockHandleInterceptEvent).toHaveBeenCalled();
+                // Verify the executeEvent function uses the port
+                const executeEventFn = mockHandleInterceptEvent.mock.calls[0][0].executeEvent;
+                expect(executeEventFn).toBeDefined();
+            });
+        });
+        test('should not process non-ApiIntercept events through handleApiInterceptEvent', async () => {
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.Save,
+                data: { answerId: '123' },
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(mockHandleInterceptEvent).not.toHaveBeenCalled();
+            });
+        });
+        test('should handle multiple ApiIntercept events', async () => {
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData1 = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockEventData2 = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=LoadContextBook',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData1, mockPort);
+            });
+            await executeAfterWait(() => {
+                postMessageToParent(getIFrameEl().contentWindow, mockEventData2, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(mockHandleInterceptEvent).toHaveBeenCalledTimes(2);
+            });
+        });
+        test('should pass eventPort to executeCallbacks', async () => {
+            let capturedExecuteEvent;
+            mockHandleInterceptEvent.mockImplementation((params) => {
+                capturedExecuteEvent = params.executeEvent;
+            });
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            const mockCallback = jest.fn();
+            searchEmbed.on(EmbedEvent.ApiIntercept, mockCallback);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(capturedExecuteEvent).toBeDefined();
+                // Call executeEvent with a response
+                const responseData = { execute: true };
+                capturedExecuteEvent(EmbedEvent.ApiIntercept, responseData);
+                // Verify the callback was invoked with the data
+                expect(mockCallback).toHaveBeenCalled();
+                expect(mockCallback.mock.calls[0][0]).toEqual(responseData);
+            });
+        });
+        test('should handle getUnsavedAnswerTml with empty response', async () => {
+            let capturedGetUnsavedAnswerTml;
+            mockHandleInterceptEvent.mockImplementation((params) => {
+                capturedGetUnsavedAnswerTml = params.getUnsavedAnswerTml;
+            });
+            mockProcessTrigger.mockResolvedValue([]);
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(async () => {
+                expect(capturedGetUnsavedAnswerTml).toBeDefined();
+                const result = await capturedGetUnsavedAnswerTml({
+                    sessionId: 'session-123',
+                    vizId: 'viz-456'
+                });
+                expect(result).toBeUndefined();
+            });
+        });
+        test('should work with LiveboardEmbed', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                liveboardId: 'test-liveboard-id',
+            });
+            await liveboardEmbed.render();
+            const mockEventData = {
+                type: EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=LoadContextBook',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(mockHandleInterceptEvent).toHaveBeenCalledTimes(1);
+                expect(mockHandleInterceptEvent).toHaveBeenCalledWith(expect.objectContaining({
+                    eventData: mockEventData,
+                }));
+            });
+        });
+    });
 });
 //# sourceMappingURL=ts-embed.spec.js.map