@wise/dynamic-flow-client 5.11.0 → 5.12.1

package/build/controller/executePoll.js

@@ -1,5 +1,6 @@
+import { normaliseBehavior } from '../domain/mappers/utils/behavior-utils';
 import { getResponseTypeFromHeader } from './getResponseType';
-import { assertActionResponseBody, assertStepResponseBody, isActionResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
+import { assertActionResponseBody, assertModalResponseBody, assertStepResponseBody, assertSubflowResponseBody, isActionResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
 export const executePoll = async (props) => {
     const { errorBehavior, signal, url, httpClient, trackEvent } = props;
     try {
@@ -27,7 +28,21 @@ export const executePoll = async (props) => {
                     assertActionResponseBody(body);
                     return { type: 'behavior', behavior: actionResponseBodyToBehavior(body) };
                 }
-                default: {
+                case 'modal': {
+                    assertModalResponseBody(body);
+                    return { type: 'behavior', behavior: Object.assign({ type: 'modal' }, body) };
+                }
+                case 'no-op': {
+                    return { type: 'behavior', behavior: { type: 'none' } };
+                }
+                case 'subflow': {
+                    assertSubflowResponseBody(body);
+                    return {
+                        type: 'behavior',
+                        behavior: normaliseBehavior(Object.assign({ type: 'subflow' }, body), []),
+                    };
+                }
+                case undefined: {
                     if (isActionResponseBody(body)) {
                         return { type: 'behavior', behavior: actionResponseBodyToBehavior(body) };
                     }

package/build/main.js

@@ -6474,7 +6474,21 @@ var executePoll = async (props) => {
           assertActionResponseBody(body);
           return { type: "behavior", behavior: actionResponseBodyToBehavior(body) };
         }
-        default: {
+        case "modal": {
+          assertModalResponseBody(body);
+          return { type: "behavior", behavior: __spreadValues({ type: "modal" }, body) };
+        }
+        case "no-op": {
+          return { type: "behavior", behavior: { type: "none" } };
+        }
+        case "subflow": {
+          assertSubflowResponseBody(body);
+          return {
+            type: "behavior",
+            behavior: normaliseBehavior(__spreadValues({ type: "subflow" }, body), [])
+          };
+        }
+        case void 0: {
           if (isActionResponseBody(body)) {
             return { type: "behavior", behavior: actionResponseBodyToBehavior(body) };
           }

package/build/main.mjs

@@ -6444,7 +6444,21 @@ var executePoll = async (props) => {
           assertActionResponseBody(body);
           return { type: "behavior", behavior: actionResponseBodyToBehavior(body) };
         }
-        default: {
+        case "modal": {
+          assertModalResponseBody(body);
+          return { type: "behavior", behavior: __spreadValues({ type: "modal" }, body) };
+        }
+        case "no-op": {
+          return { type: "behavior", behavior: { type: "none" } };
+        }
+        case "subflow": {
+          assertSubflowResponseBody(body);
+          return {
+            type: "behavior",
+            behavior: normaliseBehavior(__spreadValues({ type: "subflow" }, body), [])
+          };
+        }
+        case void 0: {
           if (isActionResponseBody(body)) {
             return { type: "behavior", behavior: actionResponseBodyToBehavior(body) };
           }

package/build/tests/ListLayout.test.js

@@ -53,6 +53,20 @@ describe('ListLayout component', () => {
                             accessibilityDescription: 'Accessibility description for additional info 2',
                         },
                     },
+                    {
+                        analyticsId: 'item-3-aid',
+                        title: 'Item 3',
+                        tag: 'tag3',
+                        supportingValues: { value: 'value3', subvalue: 'subvalue3' },
+                        callToAction: {
+                            title: 'Go to FooBar',
+                            behavior: {
+                                type: 'link',
+                                url: 'https://foo.bar',
+                            },
+                            accessibilityDescription: 'Accessibility description for item 3 link',
+                        },
+                    },
                 ],
             },
         ],
@@ -66,6 +80,15 @@ describe('ListLayout component', () => {
             await user.click(screen.getByRole('button', { name: 'Click me' }));
             expect(props.httpClient).toHaveBeenCalledWith('/item-cta', expect.anything());
         });
+        it('should render a link for the item with the correct href and accessibility description', () => {
+            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
+            const link = screen.getByRole('link', { name: 'Go to FooBar' });
+            expect(link).toBeInTheDocument();
+            expect(link).toHaveAttribute('href', 'https://foo.bar');
+            expect(link).toHaveAttribute('target', '_blank');
+            expect(link).toHaveAttribute('rel', 'noopener noreferrer');
+            expect(link).toHaveAttribute('aria-description', 'Accessibility description for item 3 link');
+        });
     });
     describe('Extra props', () => {
         const props = Object.assign(Object.assign({}, getDefaultProps()), { initialStep: getInitialStep() });

package/build/tests/Polling.test.js

@@ -8,7 +8,7 @@ import { abortableDelay, respondWith, respondWithDelay } from '../test-utils/fet
 const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
 const cases = [
     [
-        'a config with onError.behavior of type "action" (spec next)',
+        'a config with onError.behavior of type "action" (current behavior spec)',
         {
             url: '/polling',
             interval: 2,
@@ -35,7 +35,7 @@ const cases = [
         },
     ],
     [
-        'a config with onError.action',
+        'a config with onError.action (deprecated polling spec)',
         {
             url: '/polling',
             interval: 2,
@@ -614,4 +614,89 @@ describe.each(cases)('Given %s', (_, pollingConfig) => {
             expect(mockHttpClient).toHaveBeenCalledTimes(1);
         });
     });
+    describe('when the response is a modal', () => {
+        it('renders the modal content and stops polling', async () => {
+            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
+                switch (input) {
+                    case '/polling':
+                        return respondWith({ title: 'Modal Title', content: [{ type: 'paragraph', text: 'Modal content' }] }, { headers: { 'X-DF-Response-Type': 'modal' } });
+                }
+            });
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
+            await waitFor(() => {
+                expect(screen.getByText('polling title')).toBeInTheDocument();
+            });
+            expect(mockHttpClient).toHaveBeenCalledTimes(1);
+            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
+            await waitFor(() => {
+                expect(screen.getByText('Modal Title')).toBeInTheDocument();
+            });
+            expect(screen.getByText('Modal content')).toBeInTheDocument();
+            // original step remains visible behind the modal
+            expect(screen.getByText('polling title')).toBeInTheDocument();
+            // polling stops after the modal is shown
+            await vi.advanceTimersByTimeAsync(5000);
+            expect(mockHttpClient).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('when the response is a no-op', () => {
+        it('stops polling without changing the UI', async () => {
+            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
+                switch (input) {
+                    case '/polling':
+                        return respondWith(null, { headers: { 'X-DF-Response-Type': 'no-op' } });
+                }
+            });
+            const onError = vi.fn();
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: onError, onCompletion: () => { } }));
+            await waitFor(() => {
+                expect(screen.getByText('polling title')).toBeInTheDocument();
+            });
+            expect(mockHttpClient).toHaveBeenCalledTimes(1);
+            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
+            // polling stops, but nothing changes in the UI
+            await vi.advanceTimersByTimeAsync(5000);
+            expect(mockHttpClient).toHaveBeenCalledTimes(1);
+            expect(screen.getByText('polling title')).toBeInTheDocument();
+            // the flow doesn't fail
+            expect(onError).not.toHaveBeenCalled();
+        });
+    });
+    describe('when the response is a subflow', () => {
+        it('launches the subflow modally and stops polling', async () => {
+            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
+                switch (input) {
+                    case '/polling':
+                        return respondWith({
+                            referrerId: 'polling-flow',
+                            launchConfig: {
+                                type: 'dynamic',
+                                request: { url: '/subflow-start', method: 'GET' },
+                                presentation: { type: 'modal' },
+                            },
+                        }, { headers: { 'X-DF-Response-Type': 'subflow' } });
+                    case '/subflow-start':
+                        return respondWith({
+                            id: 'subflow-step',
+                            title: 'Subflow Step',
+                            schemas: [],
+                            layout: [],
+                        });
+                }
+            });
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
+            await waitFor(() => {
+                expect(screen.getByText('polling title')).toBeInTheDocument();
+            });
+            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
+            await waitFor(() => {
+                expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+            });
+            // original step still visible behind the subflow modal
+            expect(screen.getByText('polling title')).toBeInTheDocument();
+            // polling stops after the subflow is launched
+            await vi.advanceTimersByTimeAsync(5000);
+            expect(mockHttpClient).toHaveBeenCalledTimes(2); // one poll + one subflow start
+        });
+    });
 });