@wise/dynamic-flow-client 5.25.2 → 5.25.4

package/build/tests/DateInput.test.js

@@ -1,192 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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();
-        });
-    });
-});