@thoughtspot/visual-embed-sdk 1.43.0 → 1.43.1

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

@@ -23,8 +23,10 @@ const processTrigger_1 = require("../utils/processTrigger");
 const contracts_1 = require("./hostEventClient/contracts");
 const sessionInfoService = tslib_1.__importStar(require("../utils/sessionInfoService"));
 const authToken = tslib_1.__importStar(require("../authToken"));
+const apiIntercept = tslib_1.__importStar(require("../api-intercept"));
 jest.mock('../utils/processTrigger');
 const mockProcessTrigger = processTrigger_1.processTrigger;
+const mockHandleInterceptEvent = jest.spyOn(apiIntercept, 'handleInterceptEvent');
 const defaultViewConfig = {
     frameParams: {
         width: 1280,
@@ -64,6 +66,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: index_1.EmbedEvent.APP_INIT,
+        data: {
+            ...defaultData,
+            ...data,
+        },
+    };
+};
 describe('Unit test case for ts embed', () => {
     const mockMixPanelEvent = jest.spyOn(mixpanelInstance, 'uploadMixpanelEvent');
     beforeEach(() => {
@@ -247,22 +273,7 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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 () => {
@@ -283,22 +294,9 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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 () => {
@@ -323,22 +321,9 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        hostConfig: undefined,
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [types_1.HomepageModule.MyLibrary, types_1.HomepageModule.Learning],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    hiddenHomepageModules: [types_1.HomepageModule.MyLibrary, types_1.HomepageModule.Learning],
+                }));
             });
         });
         test('customVariablesForThirdPartyTools should be part of the app_init payload', async () => {
@@ -358,22 +343,7 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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 () => {
@@ -398,22 +368,9 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        hostConfig: undefined,
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        reorderedHomepageModules: [types_1.HomepageModule.MyLibrary, types_1.HomepageModule.Watchlist],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    reorderedHomepageModules: [types_1.HomepageModule.MyLibrary, types_1.HomepageModule.Watchlist],
+                }));
             });
         });
         test('Runtime parameters from view Config should be part of app_init payload when excludeRuntimeParametsfromURL is true', async () => {
@@ -441,22 +398,9 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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 () => {
@@ -485,22 +429,9 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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 () => {
@@ -528,22 +459,7 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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 () => {
@@ -572,22 +488,7 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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 () => {
@@ -612,22 +513,9 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.EmbedEvent.APP_INIT,
-                    data: {
-                        customisations,
-                        authToken: '',
-                        hostConfig: undefined,
-                        runtimeFilterParams: null,
-                        runtimeParameterParams: null,
-                        hiddenHomeLeftNavItems: [types_1.HomeLeftNavItem.Home, types_1.HomeLeftNavItem.MonitorSubscription],
-                        hiddenHomepageModules: [],
-                        hiddenListColumns: [],
-                        customActions: [],
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools,
-                    },
-                });
+                expect(mockPort.postMessage).toHaveBeenCalledWith(getMockAppInitPayload({
+                    hiddenHomeLeftNavItems: [types_1.HomeLeftNavItem.Home, types_1.HomeLeftNavItem.MonitorSubscription],
+                }));
             });
         });
         test('when Embed event status have start status', (done) => {
@@ -759,22 +647,10 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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();
         });
@@ -824,36 +700,25 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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');
@@ -929,43 +794,33 @@ describe('Unit test case for ts embed', () => {
                 (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await (0, test_utils_1.executeAfterWait)(() => {
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: index_1.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: types_1.CustomActionTarget.VIZ,
-                                position: types_1.CustomActionsPosition.MENU,
-                                metadataIds: { vizIds: ['viz456'] }
-                            },
-                            {
-                                id: 'action1',
-                                name: 'Valid Action',
-                                target: types_1.CustomActionTarget.LIVEBOARD,
-                                position: types_1.CustomActionsPosition.PRIMARY,
-                                metadataIds: { liveboardIds: ['lb123'] }
-                            }
-                        ],
-                        hostConfig: undefined,
-                        reorderedHomepageModules: [],
-                        customVariablesForThirdPartyTools: {},
                     },
-                });
+                    authToken: 'test_auth_token1',
+                    customActions: [
+                        {
+                            id: 'action2',
+                            name: 'Another Valid Action',
+                            target: types_1.CustomActionTarget.VIZ,
+                            position: types_1.CustomActionsPosition.MENU,
+                            metadataIds: { vizIds: ['viz456'] }
+                        },
+                        {
+                            id: 'action1',
+                            name: 'Valid Action',
+                            target: types_1.CustomActionTarget.LIVEBOARD,
+                            position: types_1.CustomActionsPosition.PRIMARY,
+                            metadataIds: { liveboardIds: ['lb123'] }
+                        }
+                    ],
+                    customVariablesForThirdPartyTools: {},
+                }));
                 // Verify that CustomActionsValidationResult structure is
                 // correct
                 const appInitData = mockPort.postMessage.mock.calls[0][0].data;
@@ -2909,7 +2764,7 @@ describe('Unit test case for ts embed', () => {
                 const triggerSpy = jest.spyOn(appEmbed, 'trigger').mockResolvedValue(null);
                 const removeChildSpy = jest.spyOn(Node.prototype, 'removeChild').mockImplementation(() => (0, test_utils_1.getRootEl)());
                 appEmbed.destroy();
-                // Should be called immediately when waitForCleanupOnDestroy is true
+                // Should be called immediately when config is enabled
                 expect(triggerSpy).toHaveBeenCalledWith(types_1.HostEvent.DestroyEmbed);
                 // Wait for the timeout to complete
                 await new Promise(resolve => setTimeout(resolve, 1100));
@@ -2961,5 +2816,324 @@ describe('Unit test case for ts embed', () => {
             });
         });
     });
+    describe('handleApiInterceptEvent', () => {
+        beforeEach(() => {
+            document.body.innerHTML = (0, test_utils_1.getDocumentBody)();
+            (0, index_1.init)({
+                thoughtSpotHost: 'tshost',
+                authType: index_1.AuthType.None,
+            });
+            jest.clearAllMocks();
+            mockHandleInterceptEvent.mockClear();
+        });
+        test('should call handleInterceptEvent with correct parameters', async () => {
+            const searchEmbed = new index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.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 (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.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 index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            const mockCallback = jest.fn();
+            searchEmbed.on(index_1.EmbedEvent.CustomAction, mockCallback);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.executeAfterWait)(() => {
+                expect(capturedExecuteEvent).toBeDefined();
+                // Simulate executeEvent being called by handleInterceptEvent
+                const testData = { test: 'data' };
+                capturedExecuteEvent(index_1.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 index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.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 index_1.SearchEmbed((0, test_utils_1.getRootEl)(), customViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/api/test',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.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 index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.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 index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.Save,
+                data: { answerId: '123' },
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.executeAfterWait)(() => {
+                expect(mockHandleInterceptEvent).not.toHaveBeenCalled();
+            });
+        });
+        test('should handle multiple ApiIntercept events', async () => {
+            const searchEmbed = new index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData1 = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockEventData2 = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=LoadContextBook',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData1, mockPort);
+            });
+            await (0, test_utils_1.executeAfterWait)(() => {
+                (0, test_utils_1.postMessageToParent)((0, test_utils_1.getIFrameEl)().contentWindow, mockEventData2, mockPort);
+            });
+            await (0, test_utils_1.executeAfterWait)(() => {
+                expect(mockHandleInterceptEvent).toHaveBeenCalledTimes(2);
+            });
+        });
+        test('should pass eventPort to executeCallbacks', async () => {
+            let capturedExecuteEvent;
+            mockHandleInterceptEvent.mockImplementation((params) => {
+                capturedExecuteEvent = params.executeEvent;
+            });
+            const searchEmbed = new index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            const mockCallback = jest.fn();
+            searchEmbed.on(index_1.EmbedEvent.ApiIntercept, mockCallback);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.executeAfterWait)(() => {
+                expect(capturedExecuteEvent).toBeDefined();
+                // Call executeEvent with a response
+                const responseData = { execute: true };
+                capturedExecuteEvent(index_1.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 index_1.SearchEmbed((0, test_utils_1.getRootEl)(), defaultViewConfig);
+            await searchEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=GetChartWithData',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.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 index_1.LiveboardEmbed((0, test_utils_1.getRootEl)(), {
+                ...defaultViewConfig,
+                liveboardId: 'test-liveboard-id',
+            });
+            await liveboardEmbed.render();
+            const mockEventData = {
+                type: index_1.EmbedEvent.ApiIntercept,
+                data: JSON.stringify({
+                    input: '/prism/?op=LoadContextBook',
+                    init: {}
+                })
+            };
+            const mockPort = {
+                postMessage: jest.fn(),
+            };
+            await (0, test_utils_1.executeAfterWait)(() => {
+                const iframe = (0, test_utils_1.getIFrameEl)();
+                (0, test_utils_1.postMessageToParent)(iframe.contentWindow, mockEventData, mockPort);
+            });
+            await (0, test_utils_1.executeAfterWait)(() => {
+                expect(mockHandleInterceptEvent).toHaveBeenCalledTimes(1);
+                expect(mockHandleInterceptEvent).toHaveBeenCalledWith(expect.objectContaining({
+                    eventData: mockEventData,
+                }));
+            });
+        });
+    });
 });
 //# sourceMappingURL=ts-embed.spec.js.map