@wise/dynamic-flow-client 0.4.0-beta-0489d0.8 → 0.4.0

package/README.md

@@ -19,15 +19,6 @@ npm install @wise/dynamic-flow-client
 pnpm install @wise/dynamic-flow-client
 ```
 
-**Note:** Dynamic flow is exported in three formats, minified and unminified. Most bundlers will understand the formats declared in `package.json`, but should you need to, you can find each format in the `build` folder:
-
-| Format       | Minified          | Unminified    |
-| ------------ | ----------------- | ------------- |
-| Browser      | `main.min.js`     | `main.js`     |
-| Common JS    | `main.cjs.min.js` | `main.cjs.js` |
-| ESM          | `main.esm.min.js` | `main.esm.js` |
-
-
 2. Install required peer dependencies (if not already installed). Please refer to setup instructions for `@transferwise/components` and `@transferwise/neptune-css` if installing up for the first time.
 
 ```
@@ -45,8 +36,6 @@ pnpm install @transferwise/components @transferwise/formatting @transferwise/ico
 ```
 **Note:** Keep in mind that some of these dependencies have their own peer dependencies. Don't forget to install those, for instance: `@transferwise/components` needs `@wise/art` and `@wise/components-theming`.
 
-3. Import the required CSS, and wrap the DynamicFlow component in the required design system providers.
-
 ```js
 // Should be imported once in your application
 import '@wise/dynamic-flow-client/build/main.css';

package/build/common/constants/DateMode.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+exports.DateMode = void 0;
+exports.DateMode = {
+    DAY_MONTH_YEAR: 'day-month-year',
+    MONTH_YEAR: 'month-year'
+};

package/build/common/constants/FormControlType.js

@@ -0,0 +1,20 @@
+"use strict";
+exports.__esModule = true;
+exports.FormControlType = void 0;
+exports.FormControlType = {
+    RADIO: 'radio',
+    CHECKBOX: 'checkbox',
+    SELECT: 'select',
+    FILE: 'file',
+    DATE: 'date',
+    DATETIME: 'date-time',
+    DATELOOKUP: 'date-lookup',
+    TEL: 'tel',
+    NUMBER: 'number',
+    HIDDEN: 'hidden',
+    PASSWORD: 'password',
+    TEXT: 'text',
+    TEXTAREA: 'textarea',
+    UPLOAD: 'upload',
+    TAB: 'tab'
+};

package/build/common/constants/MonthFormat.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+exports.MonthFormat = void 0;
+exports.MonthFormat = {
+    SHORT: 'short',
+    LONG: 'long'
+};

package/build/common/constants/SchemaType.js

@@ -0,0 +1,14 @@
+"use strict";
+exports.__esModule = true;
+exports.SchemaType = void 0;
+exports.SchemaType = {
+    READ_ONLY: 'readOnly',
+    PERSIST_ASYNC: 'persistAsync',
+    VALIDATION_ASYNC: 'validationAsync',
+    OBJECT: 'object',
+    PROMOTED_ONE_OF: 'promotedOneOf',
+    ONE_OF: 'oneOf',
+    ALL_OF: 'allOf',
+    BASIC: 'basic',
+    ARRAY: 'array'
+};

package/build/common/constants/Size.js

@@ -0,0 +1,10 @@
+"use strict";
+exports.__esModule = true;
+exports.Size = void 0;
+exports.Size = {
+    EXTRA_SMALL: 'xs',
+    SMALL: 'sm',
+    MEDIUM: 'md',
+    LARGE: 'lg',
+    EXTRA_LARGE: 'xl'
+};

package/build/common/constants/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+exports.__esModule = true;
+__exportStar(require("./DateMode"), exports);
+__exportStar(require("./FormControlType"), exports);
+__exportStar(require("./MonthFormat"), exports);
+__exportStar(require("./SchemaType"), exports);
+__exportStar(require("./Size"), exports);

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

@@ -0,0 +1,41 @@
+"use strict";
+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);
+};
+exports.__esModule = true;
+exports.useDynamicFlow = exports.DynamicFlowProvider = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var usePendingPromiseCounter_1 = require("./usePendingPromiseCounter");
+var defaultContextValue = {
+    loading: false,
+    registerPersistAsyncPromise: function (promise) {
+        //
+    }
+};
+var DFContext = (0, react_1.createContext)(defaultContextValue);
+var DynamicFlowProvider = function (_a) {
+    var loading = _a.loading, children = _a.children;
+    var _b = (0, usePendingPromiseCounter_1.usePendingPromiseCounter)(), pendingPromises = _b.pendingPromises, addPendingPromise = _b.addPendingPromise;
+    var providerValue = (0, react_1.useMemo)(function () {
+        return {
+            loading: loading || pendingPromises > 0,
+            registerPersistAsyncPromise: addPendingPromise
+        };
+    }, [loading, pendingPromises, addPendingPromise]);
+    return (0, jsx_runtime_1.jsx)(DFContext.Provider, __assign({ value: providerValue }, { children: children }));
+};
+exports.DynamicFlowProvider = DynamicFlowProvider;
+var useDynamicFlow = function () {
+    var context = (0, react_1.useContext)(DFContext);
+    return context || defaultContextValue;
+};
+exports.useDynamicFlow = useDynamicFlow;

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

@@ -0,0 +1,17 @@
+"use strict";
+exports.__esModule = true;
+exports.usePendingPromiseCounter = void 0;
+var react_1 = require("react");
+function usePendingPromiseCounter() {
+    var _a = (0, react_1.useState)(0), count = _a[0], setCount = _a[1];
+    var addPendingPromise = (0, react_1.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 };
+}
+exports.usePendingPromiseCounter = usePendingPromiseCounter;
+var delayUntilNextCycle = function (fn) { return setTimeout(function () { return fn(); }, 0); };
+var noop = function () {
+    // no-op
+};

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

@@ -0,0 +1,39 @@
+"use strict";
+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);
+};
+exports.__esModule = true;
+exports.getEventDispatcher = exports.useEventDispatcher = exports.EventsContextProvider = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var EventsContext = (0, react_1.createContext)({
+    triggerEvent: function () {
+        // noop
+    }
+});
+var EventsContextProvider = function (_a) {
+    var metadata = _a.metadata, children = _a.children, onEvent = _a.onEvent;
+    var value = (0, react_1.useMemo)(function () { return ({ triggerEvent: (0, exports.getEventDispatcher)(onEvent, metadata) }); }, [onEvent, metadata]);
+    return (0, jsx_runtime_1.jsx)(EventsContext.Provider, __assign({ value: value }, { children: children }));
+};
+exports.EventsContextProvider = EventsContextProvider;
+function useEventDispatcher() {
+    var triggerEvent = (0, react_1.useContext)(EventsContext).triggerEvent;
+    return triggerEvent;
+}
+exports.useEventDispatcher = useEventDispatcher;
+var getEventDispatcher = function (onEvent, metadata) {
+    return function (eventName, properties) {
+        if (properties === void 0) { properties = {}; }
+        return onEvent(eventName, __assign(__assign({}, metadata), properties));
+    };
+};
+exports.getEventDispatcher = getEventDispatcher;

package/build/common/contexts/fetcherContexts/FetcherContexts.js

@@ -0,0 +1,42 @@
+"use strict";
+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);
+};
+exports.__esModule = true;
+exports.useHasFetcherProvider = exports.useFetcher = exports.FetcherProviderFromBaseUrl = exports.FetcherProvider = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var makeFetcher_1 = require("../../makeFetcher");
+var FetcherContext = (0, react_1.createContext)(undefined);
+var FetcherProvider = function (_a) {
+    var fetcher = _a.fetcher, children = _a.children;
+    return (0, jsx_runtime_1.jsx)(FetcherContext.Provider, __assign({ value: fetcher }, { children: children }));
+};
+exports.FetcherProvider = FetcherProvider;
+var FetcherProviderFromBaseUrl = function (_a) {
+    var baseUrl = _a.baseUrl, children = _a.children;
+    var fetcher = (0, react_1.useMemo)(function () { return (0, makeFetcher_1.makeFetcher)(baseUrl); }, [baseUrl]);
+    return (0, jsx_runtime_1.jsx)(FetcherContext.Provider, __assign({ value: fetcher }, { children: children }));
+};
+exports.FetcherProviderFromBaseUrl = FetcherProviderFromBaseUrl;
+/**
+ * Provides the fetch(er) function for dynamic flows asynchronous operations.
+ */
+var useFetcher = function () {
+    var contextFetch = (0, react_1.useContext)(FetcherContext);
+    return contextFetch || fetch;
+};
+exports.useFetcher = useFetcher;
+var useHasFetcherProvider = function () {
+    var context = (0, react_1.useContext)(FetcherContext);
+    return !!context;
+};
+exports.useHasFetcherProvider = useHasFetcherProvider;

package/build/common/contexts/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+exports.__esModule = true;
+__exportStar(require("./dynamicFlowContexts/DynamicFlowContexts"), exports);
+__exportStar(require("./eventsContext/EventsContext"), exports);
+__exportStar(require("./fetcherContexts/FetcherContexts"), exports);
+__exportStar(require("./logContext/LogContext"), exports);

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

@@ -0,0 +1,45 @@
+"use strict";
+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);
+};
+exports.__esModule = true;
+exports.useLogger = exports.LogProvider = exports.getLogger = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+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) {
+        return onLog(level, "Dynamic Flow ".concat(level, " - ").concat(title, " - ").concat(description), __assign({ flowId: flowId, stepId: stepId }, extra));
+    };
+};
+exports.getLogger = getLogger;
+var LogContext = (0, react_1.createContext)(null);
+var LogProvider = function (_a) {
+    var flowId = _a.flowId, stepId = _a.stepId, children = _a.children, onLog = _a.onLog;
+    var value = (0, react_1.useMemo)(function () { return ({
+        debug: (0, exports.getLogger)('debug', onLog, flowId, stepId),
+        info: (0, exports.getLogger)('info', onLog, flowId, stepId),
+        warning: (0, exports.getLogger)('warning', onLog, flowId, stepId),
+        error: (0, exports.getLogger)('error', onLog, flowId, stepId),
+        critical: (0, exports.getLogger)('critical', onLog, flowId, stepId)
+    }); }, [onLog, flowId, stepId]);
+    return (0, jsx_runtime_1.jsx)(LogContext.Provider, __assign({ value: value }, { children: children }));
+};
+exports.LogProvider = LogProvider;
+var useLogger = function () {
+    var logging = (0, react_1.useContext)(LogContext);
+    if (logging == null) {
+        throw new Error('Logging context not found. Did you forget to wrap your component in a <LogProvider />?');
+    }
+    return logging;
+};
+exports.useLogger = useLogger;

package/build/common/hooks/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+exports.__esModule = true;
+__exportStar(require("./useDebouncedFunction/useDebouncedFunction"), exports);
+__exportStar(require("./useExternal/useExternal"), exports);
+__exportStar(require("./useExternalStepPolling/useExternalStepPolling"), exports);
+__exportStar(require("./usePersistAsync/usePersistAsync"), exports);
+__exportStar(require("./usePolling/usePolling"), exports);
+__exportStar(require("./usePrevious/usePrevious"), exports);
+__exportStar(require("./useStepPolling/useStepPolling"), exports);

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

@@ -0,0 +1,13 @@
+"use strict";
+/* References:
+- https://github.com/gnbaron/use-lodash-debounce
+- https://dmitripavlutin.com/react-throttle-debounce/
+*/
+exports.__esModule = true;
+exports.useDebouncedFunction = void 0;
+var react_1 = require("react");
+var utils_1 = require("../../utils");
+function useDebouncedFunction(callback, waitMs) {
+    return (0, react_1.useCallback)((0, utils_1.debounce)(callback, waitMs), [callback, waitMs]);
+}
+exports.useDebouncedFunction = useDebouncedFunction;

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

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

package/build/common/hooks/useExternalStepPolling/useExternalStepPolling.js

@@ -0,0 +1,73 @@
+"use strict";
+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);
+};
+exports.__esModule = true;
+exports.useExternalStepPolling = void 0;
+var react_1 = require("react");
+var __1 = require("..");
+var contexts_1 = require("../../contexts");
+/** @deprecated External step is no longer supported */
+function useExternalStepPolling(polling, onAction) {
+    var fetcher = (0, contexts_1.useFetcher)();
+    var asyncFn = (0, react_1.useMemo)(function () {
+        if (polling) {
+            return function () {
+                return fetcher(polling.url).then(function (response) {
+                    if (response.ok) {
+                        try {
+                            return response.json();
+                        }
+                        catch (_a) {
+                            throw new Error('failed');
+                        }
+                    }
+                    else {
+                        throw new Error('failed');
+                    }
+                });
+            };
+        }
+        else {
+            return undefined;
+        }
+    }, [polling, fetcher]);
+    var onPollingResponse = (0, react_1.useCallback)(function (pollingResponse) {
+        var responseHandlers = (polling === null || polling === void 0 ? void 0 : polling.responseHandlers) || [];
+        var responseHandler = responseHandlers.find(function (handler) { return handler.result === pollingResponse.result; });
+        if (responseHandler === null || responseHandler === void 0 ? void 0 : responseHandler.action) {
+            var action = responseHandler.action;
+            if (action.exit) {
+                var mergedResult = __assign(__assign({}, (action.result || {})), (pollingResponse.data || {}));
+                onAction(__assign(__assign({}, action), { result: mergedResult }));
+            }
+            else {
+                var mergedData = __assign(__assign({}, (action.data || {})), (pollingResponse.data || {}));
+                onAction(__assign(__assign({}, action), { data: mergedData }));
+            }
+            return false; // stop polling
+        }
+        return true; // continue polling
+    }, [polling === null || polling === void 0 ? void 0 : polling.responseHandlers, onAction]);
+    (0, __1.usePolling)({
+        asyncFn: asyncFn,
+        interval: (polling === null || polling === void 0 ? void 0 : polling.interval) || 0,
+        maxAttempts: (polling === null || polling === void 0 ? void 0 : polling.maxAttempts) || 0,
+        maxConsecutiveFails: (polling === null || polling === void 0 ? void 0 : polling.maxConsecutiveFails) || 0,
+        onPollingResponse: onPollingResponse,
+        onFailure: (0, react_1.useCallback)(function () {
+            if (polling) {
+                onAction(polling.onError.action);
+            }
+        }, [onAction, polling])
+    });
+}
+exports.useExternalStepPolling = useExternalStepPolling;

package/build/common/hooks/usePersistAsync/usePersistAsync.js

@@ -0,0 +1,177 @@
+"use strict";
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.usePersistAsync = void 0;
+var react_1 = require("react");
+var react_intl_1 = require("react-intl");
+var validators_1 = require("../../../common/validators");
+var PersistAsyncSchema_messages_1 = __importDefault(require("../../../jsonSchemaForm/persistAsyncSchema/PersistAsyncSchema.messages"));
+var PersistAsyncBasicSchema_1 = require("../../../jsonSchemaForm/persistAsyncSchema/persistAsyncBasicSchema/PersistAsyncBasicSchema"); // FIXME: extract these functions form that schema component to either here or their own module
+var types_1 = require("../../../types");
+var contexts_1 = require("../../contexts");
+var validators_2 = require("../../validators");
+var usePersistAsync = function (persistAsync) {
+    var _a = (0, react_1.useState)(null), abortController = _a[0], setAbortController = _a[1];
+    var fetcher = (0, contexts_1.useFetcher)();
+    var intl = (0, react_intl_1.useIntl)();
+    var schema = persistAsync.schema;
+    function handlePersistAsync(model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isInvalidSchema;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        isInvalidSchema = model instanceof Blob ? !(0, types_1.isBlobSchema)(schema) : !(0, validators_2.isValidSchema)(model, schema);
+                        if ((0, validators_1.isNull)(model) || isInvalidSchema) {
+                            handleError();
+                        }
+                        return [4 /*yield*/, performPersistAsync(model)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    }
+    var abortCurrentRequestAndGetNewAbortSignal = function () {
+        if (abortController) {
+            abortController.abort();
+        }
+        var newAbortController = new AbortController();
+        setAbortController(newAbortController);
+        return newAbortController.signal;
+    };
+    function constructFetchInit(model) {
+        var _a;
+        var isBlob = (0, types_1.isBlobSchema)(schema);
+        var signal = abortCurrentRequestAndGetNewAbortSignal();
+        var requestKey = persistAsync.param;
+        var requestBody = isBlob
+            ? wrapInFormData(requestKey, model)
+            : JSON.stringify((_a = {}, _a[requestKey] = model, _a));
+        return {
+            method: persistAsync.method,
+            headers: __assign({}, (!isBlob && { 'Content-Type': 'application/json' })),
+            body: requestBody,
+            signal: signal
+        };
+    }
+    function performPersistAsync(payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, jsonResponse, id, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, fetcher(persistAsync.url, constructFetchInit(payload))];
+                    case 1:
+                        response = _a.sent();
+                        if (!response.ok) {
+                            return [2 /*return*/, handleHTTPError(response)];
+                        }
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        jsonResponse = _a.sent();
+                        if ((0, validators_1.isObject)(jsonResponse)) {
+                            id = jsonResponse[persistAsync.idProperty];
+                            if ((0, validators_1.isString)(id) || (0, validators_1.isNumber)(id)) {
+                                return [2 /*return*/, { data: id }];
+                            }
+                        }
+                        return [2 /*return*/, handleError()];
+                    case 3:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, handleError(error_1)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    function handleHTTPError(response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var jsonResponse, error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(response.status === 422)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, response.json()];
+                    case 1:
+                        jsonResponse = _a.sent();
+                        if ((0, validators_1.isObject)(jsonResponse)) {
+                            error = (0, PersistAsyncBasicSchema_1.getErrorFromResponse)(persistAsync.param, jsonResponse);
+                            if ((0, validators_1.isString)(error)) {
+                                throw new Error(error);
+                            }
+                        }
+                        _a.label = 2;
+                    case 2: throw new Error(intl.formatMessage(PersistAsyncSchema_messages_1["default"].genericError));
+                }
+            });
+        });
+    }
+    var handleError = function (error) {
+        var message = hasStringMessage(error)
+            ? error.message
+            : intl.formatMessage(PersistAsyncSchema_messages_1["default"].genericError);
+        throw new Error(message);
+    };
+    return handlePersistAsync;
+};
+exports.usePersistAsync = usePersistAsync;
+function wrapInFormData(key, value) {
+    var formData = new FormData();
+    if (value !== null) {
+        formData.append(key, value);
+    }
+    return formData;
+}
+function hasStringMessage(value) {
+    return (0, validators_1.isObject)(value) && 'message' in value && typeof value.message === 'string';
+}