@wise/dynamic-flow-client 3.9.1 → 3.9.2-experimental-535221d

package/build/legacy/common/contexts/dynamicFlowContexts/DynamicFlowContexts.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { usePendingPromiseCounter } from './usePendingPromiseCounter';
+var defaultContextValue = {
+    loading: false,
+    registerPersistAsyncPromise: function (promise) {
+        //
+    },
+};
+var DFContext = createContext(defaultContextValue);
+export var DynamicFlowProvider = function (_a) {
+    var loading = _a.loading, children = _a.children;
+    var _b = usePendingPromiseCounter(), pendingPromises = _b.pendingPromises, addPendingPromise = _b.addPendingPromise;
+    var providerValue = useMemo(function () {
+        return {
+            loading: loading || pendingPromises > 0,
+            registerPersistAsyncPromise: addPendingPromise,
+        };
+    }, [loading, pendingPromises, addPendingPromise]);
+    return _jsx(DFContext.Provider, { value: providerValue, children: children });
+};
+export var useDynamicFlow = function () {
+    var context = useContext(DFContext);
+    return context || defaultContextValue;
+};

package/build/legacy/common/contexts/dynamicFlowContexts/usePendingPromiseCounter.js

@@ -0,0 +1,15 @@
+import { useCallback, useState } from 'react';
+export function usePendingPromiseCounter() {
+    var _a = useState(0), count = _a[0], setCount = _a[1];
+    var addPendingPromise = useCallback(function (promise) {
+        setCount(function (c) { return c + 1; });
+        promise
+            .catch(noop)
+            .finally(function () { return delayUntilNextCycle(function () { return setCount(function (c) { return Math.max(0, c - 1); }); }); });
+    }, [setCount]);
+    return { addPendingPromise: addPendingPromise, pendingPromises: count };
+}
+var delayUntilNextCycle = function (fn) { return setTimeout(function () { return fn(); }, 0); };
+var noop = function () {
+    // no-op
+};

package/build/legacy/common/contexts/eventsContext/EventsContext.js

@@ -0,0 +1,38 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+var EventsContext = createContext({
+    triggerEvent: function () {
+        // noop
+    },
+});
+export function EventsContextProvider(_a) {
+    var metadata = _a.metadata, children = _a.children, onEvent = _a.onEvent;
+    var value = useMemo(function () { return ({ triggerEvent: getEventDispatcher(onEvent, metadata) }); }, [onEvent, metadata]);
+    return _jsx(EventsContext.Provider, { value: value, children: children });
+}
+export function useEventDispatcher() {
+    var triggerEvent = useContext(EventsContext).triggerEvent;
+    return triggerEvent;
+}
+export var getEventDispatcher = function (onEvent, metadata) {
+    return function (eventName, properties) {
+        if (properties === void 0) { properties = {}; }
+        try {
+            onEvent(eventName, __assign(__assign({}, metadata), properties));
+        }
+        catch (_a) {
+            // noop
+        }
+    };
+};

package/build/legacy/common/contexts/eventsContext/EventsContext.spec.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { useEffect } from 'react';
+import { EventsContextProvider, useEventDispatcher } from './EventsContext';
+describe('Tracking Provider', function () {
+    function TestChild(_a) {
+        var eventName = _a.eventName, properties = _a.properties;
+        var onEvent = useEventDispatcher();
+        useEffect(function () {
+            onEvent(eventName, properties);
+        }, []);
+        return _jsx("span", { children: eventName });
+    }
+    describe('when provider is initialised with metadata', function () {
+        function renderComponent(onEvent) {
+            render(_jsx(EventsContextProvider, { metadata: { flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }, onEvent: onEvent, children: _jsx(TestChild, { eventName: "Dynamic Flow - Flow Started", properties: { custom: 'property' } }) }));
+        }
+        describe('and is called upon mounting', function () {
+            describe('it calls the onEvent callback', function () {
+                it('with the specified eventName', function () {
+                    var onEvent = jest.fn();
+                    renderComponent(onEvent);
+                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.anything());
+                });
+                it('with the specified custom properties', function () {
+                    var onEvent = jest.fn();
+                    renderComponent(onEvent);
+                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ custom: 'property' }));
+                });
+                it('with the specified flow and step ids any custom properties', function () {
+                    var onEvent = jest.fn();
+                    renderComponent(onEvent);
+                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }));
+                });
+            });
+        });
+        describe('and the event handler throws an error', function () {
+            it('handles the error gracefully', function () {
+                var onEvent = function () {
+                    throw new Error('Mixpanel error');
+                };
+                renderComponent(onEvent);
+                expect(renderComponent).not.toThrow();
+            });
+        });
+    });
+});

package/build/legacy/common/contexts/featureContext/FeatureContext.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+var FeatureContext = createContext([]);
+export function FeatureContextProvider(_a) {
+    var features = _a.features, children = _a.children;
+    return _jsx(FeatureContext.Provider, { value: features, children: children });
+}
+export var useFeatureFlag = function (featureName) {
+    var features = useContext(FeatureContext);
+    return features === null || features === void 0 ? void 0 : features.find(function (feature) { return feature.featureName === featureName; });
+};

package/build/legacy/common/contexts/featureContext/FeatureContext.spec.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderHook } from '@testing-library/react-hooks';
+import { FeatureName } from '../../constants/FeatureName';
+import { FeatureContextProvider, useFeatureFlag } from './FeatureContext';
+var features = [
+    {
+        featureName: FeatureName.SAMPLE_FEATURE,
+        variant: 1,
+        enabled: true,
+        initiation: 'INITIATED',
+    },
+];
+var wrapper = function (_a) {
+    var children = _a.children;
+    return (_jsx(FeatureContextProvider, { features: features, children: children }));
+};
+describe('useFeatureFlag', function () {
+    it('returns a feature by name when it exists', function () {
+        var result = renderHook(function () { return useFeatureFlag(FeatureName.SAMPLE_FEATURE); }, {
+            wrapper: wrapper,
+        }).result;
+        expect(result.current).toStrictEqual(features[0]);
+    });
+    it('returns undefined for a non-existing feature', function () {
+        var result = renderHook(function () { return useFeatureFlag('NonExistingFeature'); }, {
+            wrapper: wrapper,
+        }).result;
+        expect(result.current).toBeUndefined();
+    });
+});

package/build/legacy/common/contexts/index.js

@@ -0,0 +1,3 @@
+export * from './dynamicFlowContexts/DynamicFlowContexts';
+export * from './eventsContext/EventsContext';
+export * from './logContext/LogContext';

package/build/legacy/common/contexts/logContext/LogContext.js

@@ -0,0 +1,44 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+export var getLogger = function (level, onLog, flowId, stepId) {
+    if (flowId === void 0) { flowId = 'UNKNOWN-FLOW-ID'; }
+    if (stepId === void 0) { stepId = 'UNKNOWN-FLOW-ID'; }
+    return function (title, description, extra) {
+        try {
+            onLog(level, "Dynamic Flow ".concat(level, " - ").concat(title, " - ").concat(description), __assign({ flowId: flowId, stepId: stepId }, extra));
+        }
+        catch (_a) {
+            // noop
+        }
+    };
+};
+var LogContext = createContext(null);
+export function LogProvider(_a) {
+    var flowId = _a.flowId, stepId = _a.stepId, children = _a.children, onLog = _a.onLog;
+    var value = useMemo(function () { return ({
+        debug: getLogger('debug', onLog, flowId, stepId),
+        info: getLogger('info', onLog, flowId, stepId),
+        warning: getLogger('warning', onLog, flowId, stepId),
+        error: getLogger('error', onLog, flowId, stepId),
+        critical: getLogger('critical', onLog, flowId, stepId),
+    }); }, [onLog, flowId, stepId]);
+    return _jsx(LogContext.Provider, { value: value, children: children });
+}
+export var useLogger = function () {
+    var logging = useContext(LogContext);
+    if (logging == null) {
+        throw new Error('Logging context not found. Did you forget to wrap your component in a <LogProvider />?');
+    }
+    return logging;
+};

package/build/legacy/common/contexts/logContext/LogContext.spec.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { useEffect } from 'react';
+import { useLogger, LogProvider } from './LogContext';
+describe('Logging Provider', function () {
+    function TestChild() {
+        var log = useLogger();
+        useEffect(function () {
+            // eslint-disable-next-line testing-library/no-debugging-utils
+            log.debug('Deprecation warning', 'Some description.');
+            log.info('Invalid schema or model', 'Some description.');
+            log.warning('Action supressed', 'Some description.');
+            log.error('Deprecated schema', 'This schema is no longer supported.');
+            log.critical('Deprecated schema', 'This schema is no longer supported.');
+        }, []);
+        return _jsx("span", { children: "info,error" });
+    }
+    describe('when provider is initialised with flowId and stepId', function () {
+        function renderComponent(onLog) {
+            render(_jsx(LogProvider, { flowId: "myFlowId", stepId: "myStepId", onLog: onLog, children: _jsx(TestChild, {}) }));
+        }
+        describe('and is called within a component', function () {
+            it('calls the onLog callback', function () {
+                var onLog = jest.fn();
+                renderComponent(onLog);
+                expect(onLog).toHaveBeenCalledWith('debug', 'Dynamic Flow debug - Deprecation warning - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('info', 'Dynamic Flow info - Invalid schema or model - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('warning', 'Dynamic Flow warning - Action supressed - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('error', 'Dynamic Flow error - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('critical', 'Dynamic Flow critical - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+            });
+        });
+        describe('and the logging function throws an error', function () {
+            it('handles the error gracefully', function () {
+                var onLog = function () {
+                    throw new Error('Rollbar error');
+                };
+                renderComponent(onLog);
+                expect(renderComponent).not.toThrow();
+            });
+        });
+    });
+});

package/build/legacy/common/hooks/index.js

@@ -0,0 +1,7 @@
+export * from './useDebouncedFunction/useDebouncedFunction';
+export * from './useExternal/useExternal';
+export * from './useExternalStepPolling/useExternalStepPolling';
+export * from './usePersistAsync/usePersistAsync';
+export * from './usePolling/usePolling';
+export * from './usePrevious/usePrevious';
+export * from './useStepPolling/useStepPolling';

package/build/legacy/common/hooks/useDebouncedFunction/useDebouncedFunction.js

@@ -0,0 +1,9 @@
+/* References:
+- https://github.com/gnbaron/use-lodash-debounce
+- https://dmitripavlutin.com/react-throttle-debounce/
+*/
+import { useCallback } from 'react';
+import { debounce } from '../../utils';
+export function useDebouncedFunction(callback, waitMs) {
+    return useCallback(debounce(callback, waitMs), [callback, waitMs]);
+}

package/build/legacy/common/hooks/useDebouncedFunction/useDebouncedFunction.spec.js

@@ -0,0 +1,59 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { waitFor } from '@testing-library/react';
+import { renderHook } from '@testing-library/react-hooks';
+import { useDebouncedFunction } from './useDebouncedFunction';
+describe('useDebouncedFunction hook', function () {
+    it('debounces a callback', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var callback, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    callback = jest.fn();
+                    result = renderHook(function () { return useDebouncedFunction(callback, 200); }).result;
+                    result.current();
+                    expect(callback).not.toHaveBeenCalled();
+                    return [4 /*yield*/, waitFor(function () {
+                            expect(callback).toHaveBeenCalledTimes(1);
+                        }, { interval: 200 })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/legacy/common/hooks/useExternal/useExternal.js

@@ -0,0 +1,15 @@
+import { useEffect, useState } from 'react';
+export function useExternal(url) {
+    // If we fail to open the window, the user will need to open this on their own
+    var _a = useState(null), externalWindow = _a[0], setExternalWindow = _a[1];
+    var _b = useState(false), hasManuallyTriggered = _b[0], setHasManuallyTriggered = _b[1];
+    var dismissConfirmation = function () { return setHasManuallyTriggered(true); };
+    useEffect(function () {
+        if (url) {
+            setHasManuallyTriggered(false);
+            setExternalWindow(window.open(url, '_blank'));
+        }
+    }, [url]);
+    var requiresManualTrigger = Boolean(url && !externalWindow && !hasManuallyTriggered);
+    return { requiresManualTrigger: requiresManualTrigger, dismissConfirmation: dismissConfirmation };
+}

package/build/legacy/common/hooks/useExternal/useExternal.spec.js

@@ -0,0 +1,236 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { fireEvent, screen, waitFor } from '@testing-library/react';
+import DynamicFlow from '../../../dynamicFlow/DynamicFlow';
+import { renderWithProviders } from '../../../test-utils';
+import { getMockHttpClient, respondWith } from '../../../../test-utils';
+var mockWindowOpenSuccess = function () {
+    return window.open.mockImplementation(function () { return 'fake window'; });
+};
+var mockWindonOpenFail = function () { return window.open.mockImplementation(function () { return null; }); };
+describe('useExternal', function () {
+    var mockHttpClient = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, Promise.resolve(new Response(''))];
+    }); }); });
+    var onError = jest.fn();
+    var onCompletion = jest.fn();
+    var renderComponent = function (step) {
+        return renderWithProviders(_jsx(DynamicFlow, { flowId: "the-flow-id", initialStep: step, httpClient: mockHttpClient, onCompletion: onCompletion, onError: onError }));
+    };
+    afterEach(function () {
+        mockHttpClient.mockClear();
+        jest.restoreAllMocks();
+    });
+    describe('Given a step with an "external" property', function () {
+        var step = {
+            type: 'form',
+            id: 'external',
+            title: 'Step Title',
+            external: { url: 'https://third-party.website' },
+            layout: [{ type: 'paragraph', text: 'This is a paragraph in the step layout' }],
+            schemas: [],
+        };
+        it('attempts to open the specified URL, but ONLY ONCE', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(window, 'open');
+                        mockWindowOpenSuccess();
+                        renderComponent(step);
+                        expect(window.open).toHaveBeenCalledTimes(1);
+                        expect(window.open).toHaveBeenCalledWith('https://third-party.website', '_blank');
+                        return [4 /*yield*/, waitFor(function () {
+                                expect(window.open).toHaveBeenCalledTimes(1);
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        describe('when the window/tab fails to open', function () {
+            it('displays a confirmation UI (ExternalConfirmationStep)', function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            jest.spyOn(window, 'open');
+                            mockWindonOpenFail();
+                            renderComponent(step);
+                            return [4 /*yield*/, expect(screen.findByText('Please confirm')).resolves.toBeInTheDocument()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            describe('when the confirmation button is clicked', function () {
+                it('opens the external url and displays the step layout', function () {
+                    jest.spyOn(window, 'open');
+                    mockWindonOpenFail();
+                    renderComponent(step);
+                    expect(screen.getByText('Please confirm')).toBeInTheDocument();
+                    var confirmButton = screen.getByText('Open in new tab');
+                    window.open.mockClear();
+                    fireEvent.click(confirmButton);
+                    expect(window.open).toHaveBeenCalledTimes(1);
+                    expect(screen.getByText('This is a paragraph in the step layout')).toBeInTheDocument();
+                });
+            });
+            describe('when the cancel button is clicked', function () {
+                it('does not open the external url and displays the step layout', function () {
+                    jest.spyOn(window, 'open');
+                    mockWindonOpenFail();
+                    renderComponent(step);
+                    expect(screen.getByText('Please confirm')).toBeInTheDocument();
+                    var confirmButton = screen.getByText('Cancel');
+                    window.open.mockClear();
+                    fireEvent.click(confirmButton);
+                    expect(window.open).toHaveBeenCalledTimes(0);
+                    expect(screen.getByText('This is a paragraph in the step layout')).toBeInTheDocument();
+                });
+            });
+            describe('when a subsequent step with external is loaded using the same URL', function () {
+                var mockClient = getMockHttpClient({
+                    '/external': function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, respondWith({
+                                    type: 'form',
+                                    id: 'external',
+                                    title: 'External Step',
+                                    external: { url: 'https://third-party.website' },
+                                    layout: [
+                                        { type: 'paragraph', text: 'This is a paragraph in the external step layout' },
+                                        { type: 'button', action: { url: '/layout', title: 'Continue to layout step' } },
+                                    ],
+                                    schemas: [],
+                                })];
+                        });
+                    }); },
+                    '/layout': function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, respondWith({
+                                    type: 'form',
+                                    id: 'layout',
+                                    title: 'Layout Step',
+                                    layout: [
+                                        { type: 'paragraph', text: 'This is a paragraph in the layout step layout' },
+                                        {
+                                            type: 'button',
+                                            action: { url: '/external', title: 'Continue to external step' },
+                                        },
+                                    ],
+                                    schemas: [],
+                                })];
+                        });
+                    }); },
+                });
+                it('displays the confirmation UI (ExternalConfirmationStep) a second time', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var confirmButton;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                jest.spyOn(window, 'open');
+                                mockWindonOpenFail();
+                                renderWithProviders(_jsx(DynamicFlow, { flowId: "the-flow-id", initialAction: { method: 'GET', url: '/external' }, httpClient: mockClient, onCompletion: onCompletion, onError: onError }));
+                                return [4 /*yield*/, expect(screen.findByText('Please confirm')).resolves.toBeInTheDocument()];
+                            case 1:
+                                _a.sent();
+                                confirmButton = screen.getByText('Cancel');
+                                window.open.mockClear();
+                                fireEvent.click(confirmButton);
+                                expect(window.open).toHaveBeenCalledTimes(0);
+                                expect(screen.getByText('This is a paragraph in the external step layout')).toBeInTheDocument();
+                                fireEvent.click(screen.getByText(/continue to layout step/i));
+                                return [4 /*yield*/, expect(screen.findByText('Layout Step')).resolves.toBeInTheDocument()];
+                            case 2:
+                                _a.sent();
+                                fireEvent.click(screen.getByText(/continue to external step/i));
+                                return [4 /*yield*/, expect(screen.findByText('Please confirm')).resolves.toBeInTheDocument()];
+                            case 3:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+        describe('when the window/tab opens successfully', function () {
+            it('displays the step normally', function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            jest.spyOn(window, 'open');
+                            mockWindowOpenSuccess();
+                            renderComponent(step);
+                            return [4 /*yield*/, expect(screen.findByText('This is a paragraph in the step layout')).resolves.toBeInTheDocument()];
+                        case 1:
+                            _a.sent();
+                            expect(screen.queryByText('Please confirm')).not.toBeInTheDocument();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    describe('Given a step with a malformed "external" property', function () {
+        var step = {
+            type: 'form',
+            id: 'external',
+            title: 'Step Title',
+            external: { wrong: 'banana' },
+            layout: [{ type: 'paragraph', text: 'This is a paragraph in the step layout' }],
+            schemas: [],
+        };
+        it('does not attempt to open a new tab', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(window, 'open');
+                        mockWindowOpenSuccess();
+                        renderComponent(step);
+                        return [4 /*yield*/, waitFor(function () {
+                                expect(window.open).not.toHaveBeenCalled();
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});