@wise/dynamic-flow-client 3.2.1 → 3.2.2-short-962e290

package/build/revamp/flow/executeRefresh.js

@@ -0,0 +1,97 @@
+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 { assertStepResponseBody, isErrorResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
+export var executeRefresh = function (props) { return __awaiter(void 0, void 0, void 0, function () {
+    var abortSignal, url, model, schemaId, etag, httpClient, trackEvent, response, responseBody, body_1, newEtag, body, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                abortSignal = props.abortSignal, url = props.url, model = props.model, schemaId = props.schemaId, etag = props.etag, httpClient = props.httpClient, trackEvent = props.trackEvent;
+                trackEvent('Refresh Triggered', { schema: schemaId });
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 6, , 7]);
+                return [4 /*yield*/, httpClient(url !== null && url !== void 0 ? url : '', {
+                        method: 'POST',
+                        body: JSON.stringify(model),
+                        headers: __assign({ 'Content-Type': 'application/json' }, (etag ? { 'If-None-Match': etag } : {})),
+                        signal: abortSignal
+                    })];
+            case 2:
+                response = _a.sent();
+                if (response.status === 304) {
+                    trackEvent('Refresh Succeeded', { schema: schemaId });
+                    return [2 /*return*/, { type: 'noop' }];
+                }
+                if (!!response.ok) return [3 /*break*/, 4];
+                return [4 /*yield*/, parseResponseBodyAsJsonElement(response)["catch"](function () { return ({}); })];
+            case 3:
+                responseBody = _a.sent();
+                body_1 = isErrorResponseBody(responseBody) ? responseBody : {};
+                trackEvent('Refresh Failed', __assign({ schema: schemaId }, body_1.analytics));
+                return [2 /*return*/, { type: 'error', body: body_1 }];
+            case 4:
+                newEtag = response.headers.get('etag') || null;
+                return [4 /*yield*/, parseResponseBodyAsJsonElement(response)];
+            case 5:
+                body = _a.sent();
+                assertStepResponseBody(body);
+                trackEvent('Refresh Succeeded', { schema: schemaId });
+                return [2 /*return*/, { type: 'refresh-step', step: body, etag: newEtag }];
+            case 6:
+                error_1 = _a.sent();
+                if (error_1 instanceof DOMException && error_1.name === 'AbortError') {
+                    trackEvent('Refresh Aborted', { schema: schemaId });
+                    return [2 /*return*/, { type: 'noop' }];
+                }
+                trackEvent('Refresh Failed', { schema: schemaId });
+                return [2 /*return*/, { type: 'error', body: {} }];
+            case 7: return [2 /*return*/];
+        }
+    });
+}); };

package/build/revamp/flow/executeSubmission.js

@@ -0,0 +1,152 @@
+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 { mergeModels } from '../utils/component-utils';
+import { getResponseType } from './getResponseType';
+import { assertActionResponseBody, assertStepResponseBody, isErrorResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
+export var executeSubmission = function (props) { return __awaiter(void 0, void 0, void 0, function () {
+    var httpClient, trackEvent, triggerAction, handleErrorResponse;
+    return __generator(this, function (_a) {
+        httpClient = props.httpClient, trackEvent = props.trackEvent;
+        triggerAction = function (action, model, isInitial) { return __awaiter(void 0, void 0, void 0, function () {
+            var exit, url, _a, method, _b, result, actionId, trackSubmissionEvent, response, responseType, body, _c, etag, error_1;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        exit = action.exit, url = action.url, _a = action.method, method = _a === void 0 ? 'POST' : _a, _b = action.result, result = _b === void 0 ? null : _b, actionId = action.id;
+                        trackSubmissionEvent = !isInitial ? trackEvent : function () { };
+                        trackSubmissionEvent('Action Triggered', { actionId: actionId });
+                        if (exit && !url) {
+                            trackSubmissionEvent('Action Succeeded', { actionId: actionId });
+                            return [2 /*return*/, { type: 'complete', result: result }];
+                        }
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 13, , 14]);
+                        return [4 /*yield*/, httpClient(url !== null && url !== void 0 ? url : '', {
+                                method: method,
+                                body: method === 'GET' ? undefined : JSON.stringify(model),
+                                headers: { 'Content-Type': 'application/json' }
+                            })];
+                    case 2:
+                        response = _d.sent();
+                        if (!!response.ok) return [3 /*break*/, 4];
+                        return [4 /*yield*/, handleErrorResponse(response, actionId)];
+                    case 3: return [2 /*return*/, _d.sent()];
+                    case 4: return [4 /*yield*/, getResponseType(response)];
+                    case 5:
+                        responseType = _d.sent();
+                        return [4 /*yield*/, parseResponseBodyAsJsonElement(response)];
+                    case 6:
+                        body = _d.sent();
+                        if (exit) {
+                            return [2 /*return*/, { type: 'complete', result: mergeModels(result, body) }];
+                        }
+                        _c = responseType;
+                        switch (_c) {
+                            case 'step': return [3 /*break*/, 7];
+                            case 'exit': return [3 /*break*/, 8];
+                            case 'action': return [3 /*break*/, 9];
+                        }
+                        return [3 /*break*/, 11];
+                    case 7:
+                        {
+                            etag = response.headers.get('etag') || null;
+                            assertStepResponseBody(body);
+                            trackSubmissionEvent('Action Succeeded', { actionId: actionId });
+                            return [2 /*return*/, { type: 'replace-step', step: body, etag: etag }];
+                        }
+                        _d.label = 8;
+                    case 8:
+                        {
+                            trackSubmissionEvent('Action Succeeded', { actionId: actionId });
+                            return [2 /*return*/, { type: 'complete', result: mergeModels(result, body) }];
+                        }
+                        _d.label = 9;
+                    case 9:
+                        assertActionResponseBody(body);
+                        trackSubmissionEvent('Action Succeeded', { actionId: actionId });
+                        return [4 /*yield*/, triggerAction(body.action, null, false)];
+                    case 10: return [2 /*return*/, _d.sent()];
+                    case 11:
+                        {
+                            throw new Error("Unsupported response type: ".concat(String(responseType)));
+                        }
+                        _d.label = 12;
+                    case 12: return [3 /*break*/, 14];
+                    case 13:
+                        error_1 = _d.sent();
+                        trackSubmissionEvent('Action Failed', { actionId: actionId });
+                        throw error_1;
+                    case 14: return [2 /*return*/];
+                }
+            });
+        }); };
+        handleErrorResponse = function (response, actionId) { return __awaiter(void 0, void 0, void 0, function () {
+            var body, refreshUrl, error, validation, analytics, errors;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, parseResponseBodyAsJsonElement(response)];
+                    case 1:
+                        body = _a.sent();
+                        if (isErrorResponseBody(body)) {
+                            refreshUrl = body.refreshUrl || body.refreshFormUrl;
+                            error = body.error, validation = body.validation, analytics = body.analytics;
+                            trackEvent('Action Failed', __assign({ actionId: actionId }, analytics));
+                            errors = { error: error, validation: validation };
+                            return [2 /*return*/, refreshUrl
+                                    ? { type: 'refresh', body: { refreshUrl: refreshUrl, errors: errors } }
+                                    : { type: 'error', body: { errors: errors, analytics: analytics } }];
+                        }
+                        trackEvent('Action Failed', { actionId: actionId });
+                        return [2 /*return*/, { type: 'error', body: {} }];
+                }
+            });
+        }); };
+        return [2 /*return*/, triggerAction(props.action, props.model, props.isInitial)];
+    });
+}); };

package/build/revamp/flow/getResponseType.js

@@ -0,0 +1,76 @@
+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 '../utils/type-validators';
+import { parseResponseBodyAsJsonElement, assertResponseIsValid } from './response-utils';
+var responseTypes = ['step', 'action', 'exit'];
+/**
+ * Returns either 'step', 'action', or 'exit' based on the response headers and body.
+ * This function is async because, for legacy reasons, we still need to parse the response body as JSON
+ * to determine the response type, in cases where the response headers are not set.
+ * Ideally it should just be a matter of checking the "X-Df-Response-Type" response header.
+ */
+export var getResponseType = 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');
+                    assertDFResponseType(type);
+                    return [2 /*return*/, type];
+                }
+                if ((_b = response.headers) === null || _b === void 0 ? void 0 : _b.has('X-Df-Exit')) {
+                    return [2 /*return*/, 'exit'];
+                }
+                return [4 /*yield*/, parseResponseBodyAsJsonElement(response.clone())];
+            case 1:
+                jsonBody = _c.sent();
+                if (isObject(jsonBody) && jsonBody.action) {
+                    // TODO: use Zod to validate the action object
+                    return [2 /*return*/, 'action'];
+                }
+                return [2 /*return*/, 'step'];
+        }
+    });
+}); };
+function assertDFResponseType(type) {
+    if (!responseTypes.includes(type)) {
+        throw new Error("Unsupported X-Df-Response-Type. Allowed values are 'step', 'action', 'exit', 'error'.");
+    }
+}

package/build/revamp/flow/response-utils.js

@@ -0,0 +1,88 @@
+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 '../utils/type-validators';
+export 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;
+};
+export var parseResponseBodyAsJsonElement = 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*/];
+        }
+    });
+}); };
+export function assertActionResponseBody(body) {
+    // TODO: use zod to validate the action object instead of this
+    if (!isObject(body) || !isObject(body.action)) {
+        throw new Error('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.');
+    }
+}
+export function isErrorResponseBody(body) {
+    return Boolean(isObject(body) &&
+        (body.refreshFormUrl || body.refreshUrl || body.validation || body.error || body.analytics));
+}
+export function assertErrorResponseBody(body) {
+    // TODO: use zod to validate the error object instead of this
+    if (!isErrorResponseBody(body)) {
+        throw new Error('Incorrect error response body in error response. Expected an object with either `refreshUrl`, `validation` or `error` properties.');
+    }
+}
+export function assertStepResponseBody(body) {
+    // TODO: use zod to validate the error object instead of this
+    if (!isObject(body)) {
+        throw new Error('Incorrect response body in step response. Expected an object.');
+    }
+}

package/build/revamp/renderers/CoreContainerRenderer.js

@@ -0,0 +1,8 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+export var CoreContainerRenderer = {
+    canRenderType: 'container',
+    render: function (_a) {
+        var children = _a.children;
+        return _jsx(_Fragment, { children: children });
+    }
+};

package/build/revamp/renderers/LoadingContext.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from 'react';
+var LoadingContext = createContext({ loadingState: 'idle' });
+export var LoadingContextProvider = LoadingContext.Provider;
+export var useLoadingContext = function () {
+    var loadingState = useContext(LoadingContext).loadingState;
+    return { loadingState: loadingState, isLoading: loadingState !== 'idle' };
+};

package/build/revamp/renderers/StepRenderer.js

@@ -0,0 +1,23 @@
+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 { useMemo } from 'react';
+import { LoadingContextProvider } from './LoadingContext';
+export var StepRenderer = {
+    canRenderType: 'step',
+    render: StepRendererComponent
+};
+function StepRendererComponent(_a) {
+    var children = _a.children, loadingState = _a.loadingState;
+    var value = useMemo(function () { return ({ loadingState: loadingState }); }, [loadingState]);
+    return _jsx(LoadingContextProvider, __assign({ value: value }, { children: children }));
+}

package/build/revamp/renderers/mappers/alertComponentToProps.js

@@ -0,0 +1,4 @@
+export var alertComponentToProps = function (_a) {
+    var context = _a.context, control = _a.control, margin = _a.margin, markdown = _a.markdown;
+    return ({ type: 'alert', context: context, control: control, margin: margin, markdown: markdown });
+};

package/build/revamp/renderers/mappers/allOfComponentToProps.js

@@ -0,0 +1,11 @@
+export var allOfComponentToProps = function (_a, children) {
+    var control = _a.control, description = _a.description, help = _a.help, title = _a.title;
+    return ({
+        type: 'form-section',
+        children: children,
+        control: control,
+        description: description,
+        help: help,
+        title: title
+    });
+};

package/build/revamp/renderers/mappers/booleanInputComponentToProps.js

@@ -0,0 +1,16 @@
+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 { inputComponentToProps } from './utils/inputComponentToProps';
+export var booleanInputComponentToProps = function (component) {
+    var _a;
+    return (__assign(__assign({}, inputComponentToProps(component, 'input-boolean')), { value: (_a = component.value) !== null && _a !== void 0 ? _a : false, onChange: component.onChange.bind(component) }));
+};

package/build/revamp/renderers/mappers/boxComponentToProps.js

@@ -0,0 +1,4 @@
+export var boxComponentToProps = function (_a, children) {
+    var border = _a.border, control = _a.control, width = _a.width, margin = _a.margin;
+    return ({ type: 'box', border: border, children: children, control: control, margin: margin, width: width });
+};

package/build/revamp/renderers/mappers/buttonComponentToProps.js

@@ -0,0 +1,14 @@
+export var buttonComponentToProps = function (component) {
+    var title = component.title, control = component.control, context = component.context, disabled = component.disabled, margin = component.margin, pinOrder = component.pinOrder, size = component.size, onClick = component.onClick;
+    return {
+        type: 'button',
+        title: title,
+        control: control,
+        context: context,
+        disabled: disabled,
+        margin: margin,
+        pinOrder: pinOrder,
+        size: size,
+        onClick: onClick
+    };
+};

package/build/revamp/renderers/mappers/columnsComponentToProps.js

@@ -0,0 +1,4 @@
+export var columnsComponentToProps = function (_a, startChildren, endChildren) {
+    var bias = _a.bias, control = _a.control, margin = _a.margin;
+    return ({ type: 'columns', bias: bias, control: control, margin: margin, startChildren: startChildren, endChildren: endChildren });
+};

package/build/revamp/renderers/mappers/componentToRendererProps.js

@@ -0,0 +1,105 @@
+import { isHiddenComponent } from '../../utils/type-utils';
+import { stepComponentToProps } from '../stepComponentToProps';
+import { alertComponentToProps } from './alertComponentToProps';
+import { allOfComponentToProps } from './allOfComponentToProps';
+import { booleanInputComponentToProps } from './booleanInputComponentToProps';
+import { boxComponentToProps } from './boxComponentToProps';
+import { buttonComponentToProps } from './buttonComponentToProps';
+import { columnsComponentToProps } from './columnsComponentToProps';
+import { containerComponentToProps } from './containerComponentToProps';
+import { dateInputComponentToProps } from './dateInputComponentToProps';
+import { decisionComponentToProps } from './decisionComponentToProps';
+import { dividerComponentToProps } from './dividerComponentToProps';
+import { formComponentToProps } from './formComponentToProps';
+import { headingComponentToProps } from './headingComponentToProps';
+import { hiddenComponentToProps } from './hiddenComponentToProps';
+import { imageComponentToProps } from './imageComponentToProps';
+import { instructionsComponentToProps } from './instructionsComponentToProps';
+import { integerInputComponentToProps } from './integerInputComponentToProps';
+import { loadingIndicatorComponentToProps } from './loadingIndicatorComponentToProps';
+import { markdownComponentToProps } from './markdownComponentToProps';
+import { modalComponentToProps } from './modalComponentToProps';
+import { multiUploadInputComponentToProps } from './multiUploadInputComponentToProps';
+import { numberInputComponentToProps } from './numberInputComponentToProps';
+import { objectComponentToProps } from './objectComponentToProps';
+import { paragraphComponentToProps } from './paragraphComponentToProps';
+import { repeatableComponentToProps } from './repeatableComponentToProps';
+import { reviewComponentToProps } from './reviewComponentToProps';
+import { searchComponentToProps } from './searchComponentToProps';
+import { selectInputComponentToProps } from './selectInputComponentToProps';
+import { statusListComponentToProps } from './statusListComponentToProps';
+import { textInputComponentToProps } from './textInputComponentToProps';
+import { uploadInputComponentToProps } from './uploadInputComponentToProps';
+export var componentToRendererProps = function (component, nestedContent) {
+    var children = nestedContent.children, startChildren = nestedContent.startChildren, endChildren = nestedContent.endChildren, editableItemChildren = nestedContent.editableItemChildren;
+    if (isHiddenComponent(component)) {
+        // Any component that is hidden is mapped to the same HiddenRendererProps, and won't be rendered
+        return hiddenComponentToProps();
+    }
+    switch (component.type) {
+        case 'step':
+            return stepComponentToProps(component, children);
+        case 'alert':
+            return alertComponentToProps(component);
+        case 'all-of':
+            return allOfComponentToProps(component, children);
+        case 'boolean':
+            return booleanInputComponentToProps(component);
+        case 'box':
+            return boxComponentToProps(component, children);
+        case 'button':
+            return buttonComponentToProps(component);
+        case 'columns':
+            return columnsComponentToProps(component, startChildren, endChildren);
+        case 'container':
+            return containerComponentToProps(children);
+        case 'date':
+            return dateInputComponentToProps(component);
+        case 'decision':
+            return decisionComponentToProps(component);
+        case 'divider':
+            return dividerComponentToProps(component);
+        case 'form':
+            return formComponentToProps(component, children);
+        case 'heading':
+            return headingComponentToProps(component);
+        case 'const':
+            return hiddenComponentToProps();
+        case 'image':
+            return imageComponentToProps(component);
+        case 'instructions':
+            return instructionsComponentToProps(component);
+        case 'integer':
+            return integerInputComponentToProps(component);
+        case 'loading-indicator':
+            return loadingIndicatorComponentToProps(component);
+        case 'markdown':
+            return markdownComponentToProps(component);
+        case 'modal':
+            return modalComponentToProps(component, children);
+        case 'multi-upload':
+            return multiUploadInputComponentToProps(component);
+        case 'number':
+            return numberInputComponentToProps(component);
+        case 'object':
+            return objectComponentToProps(component, children);
+        case 'paragraph':
+            return paragraphComponentToProps(component);
+        case 'repeatable':
+            return repeatableComponentToProps(component, children !== null && children !== void 0 ? children : [], editableItemChildren);
+        case 'review':
+            return reviewComponentToProps(component);
+        case 'search':
+            return searchComponentToProps(component);
+        case 'select':
+            return selectInputComponentToProps(component, children !== null && children !== void 0 ? children : []);
+        case 'status-list':
+            return statusListComponentToProps(component);
+        case 'text':
+            return textInputComponentToProps(component);
+        case 'upload':
+            return uploadInputComponentToProps(component);
+        default:
+            throw new Error('Unknown component type');
+    }
+};

package/build/revamp/renderers/mappers/containerComponentToProps.js

@@ -0,0 +1,4 @@
+export var containerComponentToProps = function (children) { return ({
+    type: 'container',
+    children: children
+}); };

package/build/revamp/renderers/mappers/dateInputComponentToProps.js

@@ -0,0 +1,13 @@
+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 { inputComponentToProps } from './utils/inputComponentToProps';
+export var dateInputComponentToProps = function (component) { return (__assign(__assign({}, inputComponentToProps(component, 'input-date')), { minimumDate: component.minimumDate, maximumDate: component.maximumDate, onChange: component.onChange.bind(component) })); };