@wise/dynamic-flow-client 5.25.1 → 5.25.2

package/build/tests/DateInput.test.js

@@ -0,0 +1,192 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderWithProviders } from '../test-utils';
+import DynamicFlowWise from '../test-utils/DynamicFlowWise';
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from '@testing-library/react';
+const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+describe('given a step with date input', () => {
+    const step = (required, defaultValue) => ({
+        id: 'step',
+        title: 'step title',
+        schemas: [
+            {
+                properties: {
+                    date: {
+                        format: 'date',
+                        title: 'This is a date',
+                        type: 'string',
+                        default: defaultValue,
+                    },
+                },
+                required: required ? ['date'] : undefined,
+                displayOrder: ['date'],
+                $id: '#schema',
+                type: 'object',
+            },
+        ],
+        layout: [
+            {
+                schemaId: '#schema',
+                type: 'form',
+            },
+            {
+                type: 'button',
+                title: 'Submit',
+                action: { url: '/submit' },
+            },
+        ],
+    });
+    describe('when a full date is provided', () => {
+        it('submits successfully', async () => {
+            vi.setSystemTime(new Date(2026, 1, 1, 12, 0));
+            const httpClient = vi.fn();
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: step(true), onCompletion: vi.fn(), onError: vi.fn() }));
+            await user.click(screen.getAllByText('Month')[0]);
+            await waitFor(() => {
+                expect(screen.getByText('January')).toBeInTheDocument();
+            });
+            await user.click(screen.getByText('January'));
+            await user.type(screen.getByLabelText('Day'), '1');
+            await user.type(screen.getByLabelText('Year'), '2024');
+            await user.click(screen.getByText('Submit'));
+            await waitFor(() => {
+                expect(httpClient).toHaveBeenCalled();
+            });
+            expect(screen.queryByText('Please fill out this field.')).not.toBeInTheDocument();
+        });
+    });
+    describe('when a partial date (YYYY-MM) is filled in', () => {
+        describe('and the field is required', () => {
+            it('blocks submission', async () => {
+                const httpClient = vi.fn();
+                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: step(true), onCompletion: vi.fn(), onError: vi.fn() }));
+                await waitFor(() => {
+                    expect(screen.getByText('step title')).toBeInTheDocument();
+                });
+                await user.click(screen.getAllByText('Month')[0]);
+                await waitFor(() => {
+                    expect(screen.getByText('January')).toBeInTheDocument();
+                });
+                await user.click(screen.getByText('January'));
+                await user.type(screen.getByLabelText('Year'), '2024');
+                await user.click(screen.getByText('Submit'));
+                await waitFor(() => {
+                    expect(httpClient).not.toHaveBeenCalled();
+                });
+                expect(screen.getByText('Please fill out this field.')).toBeInTheDocument();
+            });
+        });
+        describe('and the field is optional', () => {
+            it('submits null', async () => {
+                const httpClient = vi.fn();
+                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: step(false), onCompletion: vi.fn(), onError: vi.fn() }));
+                await waitFor(() => {
+                    expect(screen.getByText('step title')).toBeInTheDocument();
+                });
+                await user.click(screen.getAllByText('Month')[0]);
+                await waitFor(() => {
+                    expect(screen.getByText('January')).toBeInTheDocument();
+                });
+                await user.click(screen.getByText('January'));
+                await user.type(screen.getByLabelText('Year'), '2024');
+                await user.click(screen.getByText('Submit'));
+                await waitFor(() => {
+                    expect(httpClient).toHaveBeenCalledWith('/submit', expect.objectContaining({ body: '{}' }));
+                });
+                expect(screen.queryByText('Please fill out this field.')).not.toBeInTheDocument();
+            });
+        });
+    });
+    describe('when a partial date (YYYY-MM) is provided in the model', () => {
+        describe('and the field is required', () => {
+            it('blocks submission', async () => {
+                const httpClient = vi.fn();
+                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: Object.assign(Object.assign({}, step(true)), { model: { date: '2024-07' } }), onCompletion: vi.fn(), onError: vi.fn() }));
+                await user.click(screen.getByText('Submit'));
+                await waitFor(() => {
+                    expect(httpClient).not.toHaveBeenCalled();
+                });
+                expect(screen.getByText('Please enter a date in the correct format.')).toBeInTheDocument();
+            });
+        });
+        describe('and the field is optional', () => {
+            it('submits null', async () => {
+                const httpClient = vi.fn();
+                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: Object.assign(Object.assign({}, step(false)), { model: { date: '2024-07' } }), onCompletion: vi.fn(), onError: vi.fn() }));
+                await user.click(screen.getByText('Submit'));
+                await waitFor(() => {
+                    expect(httpClient).toHaveBeenCalledWith('/submit', expect.objectContaining({ body: '{}' }));
+                });
+                expect(screen.queryByText('Please fill out this field.')).not.toBeInTheDocument();
+            });
+        });
+    });
+    it('preserves the shipped behavior difference between YYYY and YYYY-MM model values', async () => {
+        // This behavior has shipped: YYYY is parsed as 1 January while YYYY-MM remains partial.
+        // Preserving YYYY in the same way could be considered as a breaking change in a future release.
+        const httpClient = vi.fn();
+        const partialDatesStep = Object.assign(Object.assign({}, step(false)), { model: { year: '2026', yearMonth: '2026-09' }, schemas: [
+                {
+                    properties: {
+                        year: {
+                            format: 'date',
+                            title: 'Year',
+                            type: 'string',
+                        },
+                        yearMonth: {
+                            format: 'date',
+                            title: 'Year and month',
+                            type: 'string',
+                        },
+                    },
+                    displayOrder: ['year', 'yearMonth'],
+                    $id: '#schema',
+                    type: 'object',
+                },
+            ] });
+        renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: partialDatesStep, onCompletion: vi.fn(), onError: vi.fn() }));
+        await user.click(screen.getByText('Submit'));
+        await waitFor(() => {
+            expect(httpClient).toHaveBeenCalledWith('/submit', expect.objectContaining({ body: '{"year":"2026-01-01"}' }));
+        });
+    });
+    describe('when an invalid date is provided', () => {
+        const cases = [
+            { model: 'abcd-ef-gh', description: 'nonsense string in model' },
+            { model: '25-10-1985', description: 'wrong format in model' },
+            { default: 'abcd-ef-gh', description: 'nonsense string in default' },
+            { default: '25-10-1985', description: 'wrong format in default' },
+        ];
+        cases.forEach(({ model, default: defaultValue, description }) => {
+            it(`blocks submission for ${model !== null && model !== void 0 ? model : defaultValue} because "${description}"`, async () => {
+                const httpClient = vi.fn();
+                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: Object.assign(Object.assign({}, step(true, defaultValue)), { model: { date: model !== null && model !== void 0 ? model : null } }), onCompletion: vi.fn(), onError: vi.fn() }));
+                await user.click(screen.getByText('Submit'));
+                await waitFor(() => {
+                    expect(httpClient).not.toHaveBeenCalled();
+                });
+                expect(screen.getByText('Please fill out this field.')).toBeInTheDocument();
+            });
+        });
+    });
+    describe('when a date-time value is provided in the model', () => {
+        it('extracts and uses only the date portion', async () => {
+            const httpClient = vi.fn();
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: Object.assign(Object.assign({}, step(true)), { model: { date: '1985-10-25T01:18:00.000-08:00' } }), onCompletion: vi.fn(), onError: vi.fn() }));
+            await user.click(screen.getByText('Submit'));
+            await waitFor(() => {
+                expect(httpClient).toHaveBeenCalledWith('/submit', expect.objectContaining({ body: '{"date":"1985-10-25"}' }));
+            });
+        });
+    });
+    describe('when a date-time value is provided in the schema default', () => {
+        it('extracts and uses only the date portion', async () => {
+            const httpClient = vi.fn();
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: Object.assign({}, step(true, '1985-10-25T01:18:00.000-08:00')), onCompletion: vi.fn(), onError: vi.fn() }));
+            await user.click(screen.getByText('Submit'));
+            await waitFor(() => {
+                expect(httpClient).toHaveBeenCalledWith('/submit', expect.objectContaining({ body: '{"date":"1985-10-25"}' }));
+            });
+        });
+    });
+});

package/build/tests/DateSchema.test.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { renderWithProviders } from '../test-utils';
+import DynamicFlowWise from '../test-utils/DynamicFlowWise';
+const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+describe('DateSchema', () => {
+    it('disables unavailable lookup dates and shows the first matching reason', async () => {
+        const step = {
+            id: 'step',
+            title: 'Choose a date',
+            schemas: [
+                {
+                    $id: '#appointment',
+                    type: 'date',
+                    title: 'Appointment date',
+                    control: 'date-lookup',
+                    minimum: '2026-09-01',
+                    maximum: '2026-09-30',
+                    availability: {
+                        message: 'Some appointment dates are unavailable.',
+                        unavailable: [
+                            {
+                                type: 'dates',
+                                dates: ['2026-09-06'],
+                                reason: 'This date is a bank holiday.',
+                            },
+                            {
+                                type: 'weekdays',
+                                weekdays: ['sat', 'sun'],
+                                reason: 'Appointments are not available at weekends.',
+                            },
+                        ],
+                    },
+                },
+            ],
+            layout: [{ type: 'form', schemaId: '#appointment' }],
+            model: '2026-09-02',
+        };
+        renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: vi.fn(), initialStep: step, onCompletion: vi.fn(), onError: vi.fn() }));
+        await user.click(screen.getByRole('button', { name: /2 September 2026/u }));
+        expect(screen.getByText('Some appointment dates are unavailable.')).toBeInTheDocument();
+        const sunday = screen.getByRole('button', { name: /^6 September 2026/u });
+        expect(sunday).toHaveAttribute('aria-disabled', 'true');
+        await user.click(sunday);
+        expect(screen.getByText('This date is a bank holiday.')).toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: /^5 September 2026/u }));
+        expect(screen.getByText('Appointments are not available at weekends.')).toBeInTheDocument();
+    });
+    it('shows the matching availability reason for an unavailable input date', async () => {
+        const httpClient = vi.fn();
+        const step = {
+            id: 'step',
+            title: 'Enter a date',
+            schemas: [
+                {
+                    $id: '#appointment',
+                    type: 'date',
+                    title: 'Appointment date',
+                    availability: {
+                        unavailable: [
+                            {
+                                type: 'dates',
+                                dates: ['2026-09-07'],
+                                reason: 'This date is a bank holiday.',
+                            },
+                        ],
+                    },
+                },
+            ],
+            layout: [
+                { type: 'form', schemaId: '#appointment' },
+                { type: 'button', action: { url: '/submit' }, title: 'Submit' },
+            ],
+            model: '2026-09-02',
+        };
+        renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", httpClient: httpClient, initialStep: step, onCompletion: vi.fn(), onError: vi.fn() }));
+        await user.clear(screen.getByLabelText('Day'));
+        await user.type(screen.getByLabelText('Day'), '7');
+        await user.click(screen.getByRole('button', { name: 'Submit' }));
+        expect(screen.getByText('This date is a bank holiday.')).toBeInTheDocument();
+        expect(httpClient).not.toHaveBeenCalled();
+    });
+});

package/build/tests/DecisionLayout.test.js

@@ -0,0 +1,146 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { screen, waitFor } from '@testing-library/react';
+import { userEvent } from '@testing-library/user-event';
+import { vi } from 'vitest';
+import { renderWithProviders } from '../test-utils';
+import DynamicFlowWise from '../test-utils/DynamicFlowWise';
+const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+describe('DecisionLayout component', () => {
+    const getDefaultProps = () => ({
+        flowId: 'flow-id',
+        httpClient: vi.fn(),
+        onCompletion: vi.fn(),
+        onError: vi.fn(),
+        onEvent: vi.fn(),
+        onLog: vi.fn(),
+    });
+    const initialStep = {
+        id: 'step-id',
+        title: 'Step with decision',
+        layout: [
+            {
+                type: 'decision',
+                analyticsId: 'decision-layout-aid',
+                options: [
+                    {
+                        analyticsId: 'action-option-1-aid',
+                        title: 'Action Option',
+                        action: { url: '/action-option' },
+                        tag: 'action-option',
+                        additionalText: 'Additional text',
+                        inlineAlert: {
+                            context: 'warning',
+                            content: 'This is an inline alert',
+                        },
+                    },
+                    {
+                        analyticsId: 'action-option-2-aid',
+                        title: 'Behavior Action Option',
+                        behavior: {
+                            type: 'action',
+                            action: { url: '/behavior-action' },
+                        },
+                        tag: 'behavior-action-option',
+                    },
+                    {
+                        analyticsId: 'action-option-3-aid',
+                        title: 'Behavior Link Option',
+                        behavior: {
+                            type: 'link',
+                            url: '/behavior-link',
+                        },
+                        tag: 'behavior-link-option',
+                    },
+                ],
+            },
+        ],
+        schemas: [],
+    };
+    describe('Legacy action', () => {
+        describe('Given a decision layout component with an action', () => {
+            const props = Object.assign(Object.assign({}, getDefaultProps()), { initialStep });
+            it('should render a button that triggers the action on click', async () => {
+                renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
+                await waitFor(() => {
+                    expect(screen.getByRole('button', { name: 'Action Option' })).toBeInTheDocument();
+                });
+                await user.click(screen.getByRole('button', { name: 'Action Option' }));
+                expect(props.httpClient).toHaveBeenCalledWith('/action-option', expect.any(Object));
+            });
+        });
+    });
+    describe('New "union type" behavior type', () => {
+        describe('Given a decision layout component with a link behavior', () => {
+            const onLink = vi.fn();
+            const props = Object.assign(Object.assign({}, getDefaultProps()), { onLink,
+                initialStep });
+            it('should render a link that opens the url on click', async () => {
+                renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
+                await waitFor(() => {
+                    expect(screen.getByRole('link', { name: 'Behavior Link Option' })).toBeInTheDocument();
+                });
+                expect(screen.getByRole('link', { name: 'Behavior Link Option' })).toHaveAttribute('href', '/behavior-link');
+            });
+        });
+        describe('Given a decision layout component with an action behavior', () => {
+            const props = Object.assign(Object.assign({}, getDefaultProps()), { initialStep });
+            it('should trigger the action on click', async () => {
+                renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
+                await waitFor(() => {
+                    expect(screen.getByRole('button', { name: 'Behavior Action Option' })).toBeInTheDocument();
+                });
+                await user.click(screen.getByRole('button', { name: 'Behavior Action Option' }));
+                expect(props.httpClient).toHaveBeenCalledWith('/behavior-action', expect.any(Object));
+            });
+        });
+    });
+    describe('Extra props', () => {
+        const customRenderer = {
+            canRenderType: 'decision',
+            render: vi.fn(),
+        };
+        it('should pass the tag in each option to the renderer', () => {
+            const props = Object.assign(Object.assign({}, getDefaultProps()), { initialStep });
+            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { renderers: [customRenderer] })));
+            expect(customRenderer.render).toHaveBeenCalledWith(expect.objectContaining({
+                options: expect.arrayContaining([
+                    expect.objectContaining({ tag: 'action-option' }),
+                    expect.objectContaining({ tag: 'behavior-action-option' }),
+                    expect.objectContaining({ tag: 'behavior-link-option' }),
+                ]),
+            }));
+        });
+        it('should pass the additional text, supporting values, and inline alert in each option to the renderer', () => {
+            const props = Object.assign(Object.assign({}, getDefaultProps()), { initialStep });
+            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { renderers: [customRenderer] })));
+            expect(customRenderer.render).toHaveBeenCalledWith(expect.objectContaining({
+                options: expect.arrayContaining([
+                    expect.objectContaining({ additionalText: 'Additional text' }),
+                ]),
+            }));
+            expect(customRenderer.render).toHaveBeenCalledWith(expect.objectContaining({
+                options: expect.arrayContaining([
+                    expect.objectContaining({
+                        inlineAlert: {
+                            context: 'warning',
+                            content: 'This is an inline alert',
+                        },
+                    }),
+                ]),
+            }));
+        });
+        it('should pass the analyticsId in each option to the renderer', () => {
+            const props = Object.assign(Object.assign({}, getDefaultProps()), { initialStep });
+            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { renderers: [customRenderer] })));
+            expect(customRenderer.render).toHaveBeenCalledWith(expect.objectContaining({
+                analyticsId: 'decision-layout-aid',
+                options: expect.arrayContaining([
+                    expect.objectContaining({ analyticsId: 'action-option-1-aid' }),
+                    expect.objectContaining({ analyticsId: 'action-option-2-aid' }),
+                    expect.objectContaining({ analyticsId: 'action-option-3-aid' }),
+                ]),
+            }));
+        });
+    });
+});

package/build/tests/DelayBehavior.test.js

@@ -0,0 +1,186 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { act, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { renderWithProviders, respondWith, respondWithEmptyOk } from '../test-utils';
+import DynamicFlowWise from '../test-utils/DynamicFlowWise';
+const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+describe('DelayBehavior', () => {
+    describe('given an action behavior', () => {
+        it('executes the action after the delay', async () => {
+            const httpClient = vi
+                .fn()
+                .mockImplementation(() => respondWith({ title: 'New step', layout: [], schemas: [], id: 'newStepId' }));
+            const step = {
+                id: 'step',
+                title: 'Step',
+                schemas: [],
+                layout: [{ type: 'button', title: 'Blocked' }],
+                onLoad: {
+                    type: 'delay',
+                    duration: 2,
+                    behavior: { type: 'action', action: { url: '/submit', method: 'POST' } },
+                },
+            };
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn() }));
+            expect(screen.getByRole('button', { name: 'Blocked' })).toBeDisabled();
+            await act(async () => vi.advanceTimersByTimeAsync(1000));
+            expect(httpClient).not.toHaveBeenCalled();
+            await act(async () => vi.advanceTimersByTimeAsync(1000));
+            expect(httpClient).toHaveBeenCalledWith('/submit', expect.anything());
+            expect(screen.getByText('New step')).toBeInTheDocument();
+        });
+        it('executes the action, triggering validation if the form is invalid', async () => {
+            const httpClient = vi.fn();
+            const step = {
+                id: 'step',
+                title: 'Step',
+                schemas: [
+                    {
+                        $id: '#form',
+                        type: 'string',
+                        title: 'Name',
+                    },
+                ],
+                layout: [{ type: 'form', schemaId: '#form' }],
+                onLoad: {
+                    type: 'delay',
+                    duration: 2,
+                    behavior: { type: 'action', action: { url: '/submit', method: 'POST' } },
+                },
+            };
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn() }));
+            await act(async () => vi.advanceTimersByTimeAsync(1000));
+            expect(screen.queryByText('Please fill out this field.')).not.toBeInTheDocument();
+            await act(async () => vi.advanceTimersByTimeAsync(1000));
+            expect(screen.getByText('Please fill out this field.')).toBeInTheDocument();
+        });
+    });
+    describe('given a link behavior', () => {
+        it('executes the wrapped behavior after the duration in seconds', async () => {
+            const onLink = vi.fn();
+            const step = {
+                id: 'step',
+                title: 'Step',
+                schemas: [],
+                layout: [{ type: 'button', title: 'Blocked' }],
+                onLoad: {
+                    type: 'delay',
+                    duration: 2,
+                    behavior: { type: 'link', url: 'https://wise.com' },
+                },
+            };
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: vi.fn(), onCompletion: vi.fn(), onError: vi.fn(), onLink: onLink }));
+            expect(screen.getByRole('button', { name: 'Blocked' })).toBeDisabled();
+            await act(async () => vi.advanceTimersByTimeAsync(1000));
+            expect(onLink).not.toHaveBeenCalled();
+            await act(async () => vi.advanceTimersByTimeAsync(1000));
+            expect(onLink).toHaveBeenCalledWith('https://wise.com');
+            expect(screen.getByRole('button', { name: 'Blocked' })).toBeEnabled();
+        });
+        it('allows the wrapped action to execute while the delay is blocking the step', async () => {
+            const httpClient = vi.fn(respondWithEmptyOk);
+            const step = {
+                id: 'step',
+                title: 'Step',
+                schemas: [],
+                layout: [
+                    {
+                        type: 'button',
+                        title: 'Continue',
+                        behavior: {
+                            type: 'delay',
+                            duration: 1,
+                            behavior: { type: 'action', action: { url: '/continue' } },
+                        },
+                    },
+                ],
+            };
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn() }));
+            await user.click(screen.getByRole('button', { name: 'Continue' }));
+            expect(httpClient).not.toHaveBeenCalled();
+            await act(async () => vi.advanceTimersByTimeAsync(1000));
+            expect(httpClient).toHaveBeenCalledWith('/continue', expect.anything());
+        });
+        it('cancels a pending delay when the flow is unmounted', async () => {
+            const onLink = vi.fn();
+            const step = {
+                id: 'step',
+                title: 'Step',
+                schemas: [],
+                layout: [],
+                onLoad: {
+                    type: 'delay',
+                    duration: 1,
+                    behavior: { type: 'link', url: 'https://wise.com' },
+                },
+            };
+            const { unmount } = renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: vi.fn(), onCompletion: vi.fn(), onError: vi.fn(), onLink: onLink }));
+            unmount();
+            await act(async () => vi.runAllTimersAsync());
+            expect(onLink).not.toHaveBeenCalled();
+        });
+        it('shows a confirmation modal when link opening fails, and the button is re-enabled', async () => {
+            const onLink = vi.fn().mockReturnValueOnce(false);
+            const step = {
+                id: 'step',
+                title: 'Step',
+                schemas: [],
+                layout: [
+                    {
+                        type: 'button',
+                        title: 'Continue',
+                        behavior: {
+                            type: 'action',
+                            action: {},
+                        },
+                    },
+                ],
+                onLoad: {
+                    type: 'delay',
+                    duration: 1,
+                    behavior: { type: 'link', url: 'https://wise.com' },
+                },
+            };
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: vi.fn(), onCompletion: vi.fn(), onError: vi.fn(), onLink: onLink }));
+            await act(async () => vi.runAllTimersAsync());
+            expect(onLink).toHaveBeenCalled();
+            await waitFor(() => {
+                expect(screen.getByText(/Please confirm you want to open/)).toBeInTheDocument();
+            });
+            expect(screen.getByRole('button', { name: 'Continue' })).toBeEnabled();
+        });
+        it('overrides the confirmation dialog from external', async () => {
+            const onLink = vi.fn().mockReturnValue(false);
+            const step = {
+                id: 'step',
+                title: 'Step',
+                schemas: [],
+                layout: [
+                    {
+                        type: 'button',
+                        title: 'Continue',
+                        behavior: {
+                            type: 'delay',
+                            duration: 5,
+                            behavior: { type: 'link', url: 'https://wise2.com' },
+                        },
+                    },
+                ],
+                external: {
+                    url: 'https://wise.com',
+                },
+            };
+            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: vi.fn(), onCompletion: vi.fn(), onError: vi.fn(), onLink: onLink }));
+            expect(onLink).toHaveBeenCalledOnce();
+            expect(onLink).toHaveBeenCalledWith('https://wise.com');
+            expect(screen.getByText(/Please confirm you want to open/)).toBeInTheDocument();
+            expect(screen.getByText('https://wise.com')).toBeInTheDocument();
+            await user.click(screen.getByRole('button', { name: 'Continue' }));
+            await act(async () => vi.advanceTimersByTimeAsync(5000));
+            expect(onLink).toHaveBeenCalledTimes(2);
+            expect(onLink).toHaveBeenCalledWith('https://wise2.com');
+            expect(screen.getByText(/Please confirm you want to open/)).toBeInTheDocument();
+            expect(screen.getByText('https://wise2.com')).toBeInTheDocument();
+        });
+    });
+});