@wise/dynamic-flow-client 0.0.0-experimental-20240319142919

package/build/legacy/dynamicFlow/DynamicFlow.js

@@ -0,0 +1,346 @@
+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);
+};
+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 { useCallback, useEffect, useMemo, useState } from 'react';
+import { useIntl } from 'react-intl';
+import { DynamicFlowProvider, getEventDispatcher, EventsContextProvider, LogProvider, getLogger, } from '../common/contexts';
+import { FeatureContextProvider } from '../common/contexts/featureContext/FeatureContext';
+import { isObjectModel } from '../common/utils';
+import { isValidSchema } from '../common/validators';
+import { DynamicFlowStep } from './DynamicFlowStep';
+import { ErrorBoundary, useLoader, useDynamicFlowState, useDebouncedRefresh, parseFetchResponse, getJsonObjectOrNull, parseErrorResponse, } from './utils';
+import { HttpClientProvider } from '../../common/httpClientContext';
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+var noop = function () { };
+/**
+ * ## DynamicFlow
+ *
+ * The dynamic flow component is responsible for the asynchronous actions occuring
+ * within a dynamic flow, managing transitions between steps as well as refreshing
+ * requirements.  It doesn't control any view logic, but takes the step definition
+ * and reformats it to use a LayoutStep for presentation.
+ *
+ */
+// eslint-disable-next-line react/function-component-definition
+var DynamicFlowComponent = function (_a) {
+    var flowId = _a.flowId, httpClient = _a.httpClient, initialAction = _a.initialAction, initialStep = _a.initialStep, loaderConfig = _a.loaderConfig, _b = _a.displayStepTitle, displayStepTitle = _b === void 0 ? true : _b, features = _a.features, onCompletion = _a.onCompletion, onError = _a.onError, _c = _a.onEvent, onEvent = _c === void 0 ? noop : _c, _d = _a.onLog, onLog = _d === void 0 ? noop : _d;
+    var locale = useIntl().locale;
+    var _e = useDynamicFlowState(initialStep), formErrors = _e.formErrors, globalError = _e.globalError, step = _e.step, models = _e.models, etag = _e.etag, modelIsValid = _e.modelIsValid, setFormErrors = _e.setFormErrors, setGlobalError = _e.setGlobalError, setStepAndEtag = _e.setStepAndEtag, setSchemaModel = _e.setSchemaModel;
+    var _f = useState(false), submitted = _f[0], setSubmitted = _f[1];
+    var _g = useLoader(loaderConfig, initialStep ? 'idle' : 'initial'), isLoading = _g.isLoading, loader = _g.loader, setLoadingState = _g.setLoadingState;
+    var logCritical = getLogger('critical', onLog, flowId, (step === null || step === void 0 ? void 0 : step.id) || (step === null || step === void 0 ? void 0 : step.key));
+    var logWarning = getLogger('warning', onLog, flowId, (step === null || step === void 0 ? void 0 : step.id) || (step === null || step === void 0 ? void 0 : step.key));
+    var warnIfNoStepLayout = function (step) {
+        if (step && !step.layout) {
+            logWarning('Deprecation warning', 'Support for steps with no layout is being dropped. Please add a layout array to your step.', {
+                stepId: step.id || step.key
+            });
+        }
+    };
+    var analyticsMetadata = useMemo(function () { var _a; return (__assign({ flowId: flowId, stepId: (step === null || step === void 0 ? void 0 : step.id) || (step === null || step === void 0 ? void 0 : step.key) }, ((_a = step === null || step === void 0 ? void 0 : step.analytics) !== null && _a !== void 0 ? _a : {}))); }, [flowId, step]);
+    var dispatchEvent = useMemo(function () { return getEventDispatcher(onEvent, analyticsMetadata); }, [onEvent, analyticsMetadata]);
+    var dfHttpClient = useCallback(function (_a) {
+        var action = _a.action, data = _a.data, etag = _a.etag;
+        var url = action.url, _b = action.method, method = _b === void 0 ? 'POST' : _b;
+        return httpClient(url !== null && url !== void 0 ? url : '', {
+            method: method,
+            headers: __assign({ 'accept-language': locale, 'Content-Type': 'application/json' }, (etag ? { 'If-None-Match': etag } : {})),
+            credentials: 'include',
+            body: method === 'GET' ? undefined : JSON.stringify(data)
+        });
+    }, [httpClient, locale]);
+    var performAction = function (action, data) {
+        if (data === void 0) { data = {}; }
+        return __awaiter(void 0, void 0, void 0, function () {
+            var response, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setLoadingState(!step ? 'initial' : 'submission');
+                        dispatchEvent('Dynamic Flow - Step Submitted', { actionId: action.id || action.$id });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        return [4 /*yield*/, dfHttpClient({ action: action, data: data })];
+                    case 2:
+                        response = _a.sent();
+                        if (!(action.exit && response.ok)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, handleExitResponse(response, action.result)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 4: return [4 /*yield*/, handleResponse(response, 'submission')];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        error_1 = _a.sent();
+                        completeWithError(error_1, action.exit ? 'Error fetching exit result' : 'Error fetching next step');
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    var performRefresh = function (url, data, etag) { return __awaiter(void 0, void 0, void 0, function () {
+        var response, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setLoadingState('refresh');
+                    dispatchEvent('Dynamic Flow - Step Refreshed', { status: 'pending' });
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, dfHttpClient({ action: { url: url, method: 'POST' }, data: data, etag: etag })];
+                case 2:
+                    response = _a.sent();
+                    return [4 /*yield*/, handleResponse(response, 'refresh')];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    error_2 = _a.sent();
+                    completeWithError(error_2, 'Error fetching refresh step');
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    var handleExitResponse = function (response, actionResult) { return __awaiter(void 0, void 0, void 0, function () {
+        var exitResult;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getJsonObjectOrNull(response)];
+                case 1:
+                    exitResult = _a.sent();
+                    dispatchEventAndComplete(__assign(__assign({}, exitResult), actionResult));
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var debouncedRefresh = useDebouncedRefresh(performRefresh);
+    var dispatchEventAndComplete = useCallback(function (result) {
+        dispatchEvent('Dynamic Flow - Flow Finished', { result: 'success' });
+        onCompletion(result);
+    }, [onCompletion, dispatchEvent]);
+    useEffect(function () {
+        dispatchEvent('Dynamic Flow - Flow Started', {});
+    }, []);
+    useEffect(function () {
+        if (!initialStep) {
+            var action = __assign({ id: '#initial-step-request', method: 'GET' }, initialAction);
+            void performAction(action, action.data);
+        }
+        if (initialStep) {
+            warnIfNoStepLayout(initialStep);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [httpClient, locale, JSON.stringify(initialStep), JSON.stringify(initialAction)]);
+    var handleResponse = function (response, fetchType) { return __awaiter(void 0, void 0, void 0, function () {
+        var errorResponse, result, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 4, , 5]);
+                    if (response.status === 304) {
+                        setLoadingState('idle');
+                        return [2 /*return*/];
+                    }
+                    if (!!response.ok) return [3 /*break*/, 2];
+                    return [4 /*yield*/, parseErrorResponse(response)];
+                case 1:
+                    errorResponse = _a.sent();
+                    void updateAfterError(errorResponse);
+                    return [2 /*return*/];
+                case 2: return [4 /*yield*/, parseFetchResponse(response)];
+                case 3:
+                    result = _a.sent();
+                    if (result.type === 'action') {
+                        void performAction(result.action, result.action.data);
+                    }
+                    else if (result.type === 'exit') {
+                        dispatchEventAndComplete(result.result);
+                    }
+                    else {
+                        updateStep(result.step, result.etag, fetchType);
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    error_3 = _a.sent();
+                    completeWithError(error_3, 'Error parsing fetch response', fetchType, response.status);
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    var updateStep = function (newStep, etag, fetchType) {
+        warnIfNoStepLayout(newStep);
+        setStepAndEtag(newStep, etag);
+        setLoadingState('idle');
+        if (fetchType === 'submission') {
+            setSubmitted(false);
+            dispatchEvent('Dynamic Flow - Step Started', __assign({ stepId: newStep.id || newStep.key }, newStep === null || newStep === void 0 ? void 0 : newStep.analytics));
+        }
+        else {
+            dispatchEvent('Dynamic Flow - Step Refreshed', { status: 'success' });
+        }
+    };
+    var updateAfterError = function (errorBody) { return __awaiter(void 0, void 0, void 0, function () {
+        var refreshUrl;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    refreshUrl = errorBody.refreshUrl || errorBody.refreshFormUrl;
+                    if (!refreshUrl) return [3 /*break*/, 2];
+                    return [4 /*yield*/, performRefresh(refreshUrl, combineModels(models), etag)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    if (errorBody.validation) {
+                        setFormErrors(errorBody.validation);
+                    }
+                    if (errorBody.error) {
+                        setGlobalError(errorBody.error);
+                    }
+                    setLoadingState('idle');
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var completeWithError = function (error, message, fetchType, responseStatus) {
+        logCritical('Error fetching', message);
+        if (fetchType === 'refresh') {
+            dispatchEvent('Dynamic Flow - Step Refreshed', { status: 'failure' });
+        }
+        dispatchEvent('Dynamic Flow - Flow Finished', { status: 'failure' });
+        onError(error, responseStatus);
+        setLoadingState('idle');
+    };
+    var onModelChange = function (onModelChangeProps) {
+        var model = onModelChangeProps.model, formSchema = onModelChangeProps.formSchema;
+        var _a = formSchema.$id, $id = _a === void 0 ? '' : _a;
+        setGlobalError(null);
+        if (!isObjectModel(model)) {
+            // TODO: DF-473 - Remove type assertions once we're confident people have had time to fix any errors
+            logCritical('Invalid model on change', 'onModelChange was called but the model argument is not an object');
+        }
+        var objectModel = model;
+        setSchemaModel($id, objectModel, function (updatedModels) {
+            refreshOnChangeIfNeeded(onModelChangeProps, updatedModels);
+        });
+    };
+    var refreshOnChangeIfNeeded = function (props, updatedModels) {
+        var triggerSchema = props.triggerSchema;
+        if (shouldTriggerRefresh(props)) {
+            var triggerSchemaRefreshUrl = triggerSchema.refreshUrl || triggerSchema.refreshFormUrl;
+            var stepRefreshUrl = (step === null || step === void 0 ? void 0 : step.refreshUrl) || (step === null || step === void 0 ? void 0 : step.refreshFormUrl);
+            var refreshUrl = triggerSchemaRefreshUrl || stepRefreshUrl;
+            if (refreshUrl) {
+                debouncedRefresh(refreshUrl, combineModels(updatedModels), etag, triggerSchema);
+            }
+        }
+    };
+    // FIXME: We should annotate the entire onAction function with the type OnAction
+    var onAction = function (action) { return __awaiter(void 0, void 0, void 0, function () {
+        var data, method, skipValidation, submissionData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (isLoading || action.disabled) {
+                        return [2 /*return*/];
+                    }
+                    if (action.exit && !action.url) {
+                        dispatchEventAndComplete(action.result);
+                        return [2 /*return*/];
+                    }
+                    data = action.data, method = action.method, skipValidation = action.skipValidation;
+                    submissionData = __assign(__assign({}, combineModels(models)), data);
+                    if (!isSubmissionMethod(method)) return [3 /*break*/, 3];
+                    setFormErrors(null);
+                    if (!skipValidation) {
+                        setSubmitted(true);
+                    }
+                    if (!(modelIsValid || skipValidation)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, performAction(action, submissionData)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [3 /*break*/, 5];
+                case 3: return [4 /*yield*/, performAction(action)];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    return (_jsx(LogProvider, __assign({ flowId: flowId, stepId: (step === null || step === void 0 ? void 0 : step.id) || (step === null || step === void 0 ? void 0 : step.key), onLog: onLog }, { children: _jsx(EventsContextProvider, __assign({ metadata: analyticsMetadata, onEvent: onEvent }, { children: _jsx(DynamicFlowProvider, __assign({ loading: isLoading }, { children: _jsx(HttpClientProvider, __assign({ httpClient: httpClient }, { children: _jsx(FeatureContextProvider, __assign({ features: features }, { children: loader !== null ? (loader) : (_jsx(DynamicFlowStep, { step: step, model: combineModels(models), submitted: submitted, globalError: globalError, formErrors: formErrors, stepLayoutOptions: { displayStepTitle: displayStepTitle }, onAction: function (action) {
+                                void onAction(action);
+                            }, onModelChange: onModelChange })) })) })) })) })) })));
+};
+function DynamicFlow(props) {
+    return (_jsx(ErrorBoundary, __assign({ onError: props.onError }, { children: _jsx(DynamicFlowComponent, __assign({}, props)) })));
+}
+export default DynamicFlow;
+var combineModels = function (formModels) {
+    return Object.values(formModels).reduce(function (previous, model) { return (__assign(__assign({}, previous), model)); }, {});
+};
+var isSubmissionMethod = function (method) {
+    if (method === void 0) { method = 'POST'; }
+    var submissionMethods = ['POST', 'PUT', 'PATCH'];
+    return submissionMethods.includes(method.toUpperCase());
+};
+var shouldTriggerRefresh = function (props) {
+    var type = props.type, triggerSchema = props.triggerSchema, triggerModel = props.triggerModel, _a = props.lastTriggerModel, lastTriggerModel = _a === void 0 ? null : _a;
+    var isValid = function () { return isValidSchema(triggerModel, triggerSchema); };
+    var wasValid = function () { return isValidSchema(lastTriggerModel, triggerSchema); };
+    var hasRefreshOnChange = (triggerSchema === null || triggerSchema === void 0 ? void 0 : triggerSchema.refreshStepOnChange) || (triggerSchema === null || triggerSchema === void 0 ? void 0 : triggerSchema.refreshFormOnChange);
+    return type !== 'init' && hasRefreshOnChange && (isValid() || wasValid());
+};

package/build/legacy/dynamicFlow/DynamicFlowStep.js

@@ -0,0 +1,37 @@
+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, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useExternal } from '../common/hooks';
+import { isCameraStep } from '../common/utils';
+import { DynamicAlert } from '../layout';
+import { CameraStep, LayoutStep, ExternalConfirmationStep } from '../step';
+import BackButton from './BackButton';
+export function DynamicFlowStep(props) {
+    var _a, _b, _c;
+    var step = props.step, globalError = props.globalError, onAction = props.onAction;
+    var externalUrl = (_a = step === null || step === void 0 ? void 0 : step.external) === null || _a === void 0 ? void 0 : _a.url;
+    var backButton = ((_b = step === null || step === void 0 ? void 0 : step.navigation) === null || _b === void 0 ? void 0 : _b.back) || ((_c = step === null || step === void 0 ? void 0 : step.navigation) === null || _c === void 0 ? void 0 : _c.backButton);
+    var _d = useExternal(externalUrl), requiresManualTrigger = _d.requiresManualTrigger, dismissConfirmation = _d.dismissConfirmation;
+    if (step === undefined) {
+        if (globalError) {
+            return (_jsx(DynamicAlert, { component: { context: 'negative', markdown: globalError, margin: 'lg' } }));
+        }
+        return null;
+    }
+    if (externalUrl && requiresManualTrigger) {
+        return _jsx(ExternalConfirmationStep, { url: externalUrl, onClose: dismissConfirmation });
+    }
+    if (isCameraStep(step)) {
+        return _jsx(CameraStep, __assign({}, props, { step: step }));
+    }
+    return (_jsxs(_Fragment, { children: [backButton && _jsx(BackButton, __assign({}, backButton, { onAction: onAction })), globalError ? (_jsx(DynamicAlert, { component: { context: 'negative', markdown: globalError, margin: 'lg' } })) : null, _jsx(LayoutStep, __assign({}, props, { stepSpecification: step }))] }));
+}

package/build/legacy/dynamicFlow/DynamicFlowTypes.js

@@ -0,0 +1 @@
+export {};

package/build/legacy/dynamicFlow/index.js

@@ -0,0 +1 @@
+export { default } from './DynamicFlow';

package/build/legacy/dynamicFlow/utils/index.js

@@ -0,0 +1,5 @@
+export * from './useDebouncedRefresh/useDebouncedRefresh';
+export * from './useDynamicFlowState';
+export * from './useLoader';
+export { default as ErrorBoundary } from '../../../common/errorBoundary/ErrorBoundary';
+export * from './responseParsers/response-parsers';

package/build/legacy/dynamicFlow/utils/responseParsers/response-parsers.js

@@ -0,0 +1,185 @@
+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 { isObject } from '../../../common/validators';
+var parseFetchResponseByResponseType = function (response, type) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (type) {
+            case 'step':
+                return [2 /*return*/, parseStepResponse(response)];
+            case 'exit':
+                return [2 /*return*/, parseExitResponse(response)];
+            case 'action':
+                return [2 /*return*/, parseActionResponse(response)];
+            default:
+                throw new Error("Unsupported X-Df-Response-Type. Allowed values are 'step', 'action', 'exit'.");
+        }
+        return [2 /*return*/];
+    });
+}); };
+var parseStepResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody, etag;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                jsonBody = _a.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in response. Expected an object.');
+                }
+                etag = response.headers.get('etag') || undefined;
+                return [2 /*return*/, { type: 'step', step: jsonBody, etag: etag }];
+        }
+    });
+}); };
+var parseActionResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody, action;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                jsonBody = _a.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in response. Expected an object.');
+                }
+                if (!isObject(jsonBody.action)) {
+                    throw new Error('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.');
+                }
+                action = jsonBody.action;
+                if (action.exit === true && isObject(action.result)) {
+                    return [2 /*return*/, { type: 'exit', result: action.result }];
+                }
+                return [2 /*return*/, { type: 'action', action: jsonBody.action }];
+        }
+    });
+}); };
+var parseExitResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = { type: 'exit' };
+                return [4 /*yield*/, getJsonObjectOrNull(response)];
+            case 1: return [2 /*return*/, (_a.result = _b.sent(), _a)];
+        }
+    });
+}); };
+export var parseFetchResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var type, jsonBody;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                assertResponseIsValid(response);
+                if ((_a = response.headers) === null || _a === void 0 ? void 0 : _a.has('X-Df-Response-Type')) {
+                    type = response.headers.get('X-Df-Response-Type');
+                    return [2 /*return*/, parseFetchResponseByResponseType(response, type)];
+                }
+                if ((_b = response.headers) === null || _b === void 0 ? void 0 : _b.has('X-Df-Exit')) {
+                    return [2 /*return*/, parseExitResponse(response)];
+                }
+                return [4 /*yield*/, parseResponseJson(response.clone())];
+            case 1:
+                jsonBody = _c.sent();
+                if (isObject(jsonBody) && jsonBody.action) {
+                    return [2 /*return*/, parseActionResponse(response)];
+                }
+                return [2 /*return*/, parseStepResponse(response)];
+        }
+    });
+}); };
+export var parseErrorResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                assertResponseIsValid(response);
+                return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                jsonBody = _a.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in error response. Expected an object.');
+                }
+                if (!jsonBody.refreshFormUrl && !jsonBody.refreshUrl && !jsonBody.validation && !jsonBody.error) {
+                    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+                    throw jsonBody;
+                }
+                return [2 /*return*/, jsonBody];
+        }
+    });
+}); };
+export var getJsonObjectOrNull = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                assertResponseIsValid(response);
+                return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                result = _a.sent();
+                return [2 /*return*/, isObject(result) ? result : null];
+        }
+    });
+}); };
+var parseResponseJson = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, response.json()];
+            case 1: return [2 /*return*/, (_b.sent())];
+            case 2:
+                _a = _b.sent();
+                return [2 /*return*/, null];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+var assertResponseIsValid = function (response) {
+    if (!isResponse(response)) {
+        throw new Error('Incorrect type of response from fetch. Expected object of type Response.');
+    }
+    if (response.bodyUsed) {
+        throw new Error('The body of the provided Response object has already been used. Every request must respond with a new Response object.');
+    }
+};
+var isResponse = function (response) {
+    return typeof response === 'object' &&
+        response !== null &&
+        'clone' in response &&
+        'bodyUsed' in response;
+};