@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/common/api/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isStatus2xx(status: Response['status']): boolean;
+export declare function isStatus422(status: Response['status']): boolean;
+export declare function getJson(response: Response): Promise<any>;
+export declare function isRelativePath(url?: string): boolean;

package/build/common/api/utils.js

@@ -0,0 +1,13 @@
+export function isStatus2xx(status) {
+    return status >= 200 && status < 300;
+}
+export function isStatus422(status) {
+    return status === 422;
+}
+export function getJson(response) {
+    return response.json();
+}
+export function isRelativePath(url) {
+    if (url === void 0) { url = ''; }
+    return (['https://', 'http://', 'data:'].some(function (prefix) { return url.slice(0, prefix.length) === prefix && url.length > prefix.length; }) === false);
+}

package/build/common/contexts/dynamicFlowContext/dynamicFlowContext.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+type Props = {
+    loading: boolean;
+    children: React.ReactNode;
+};
+export declare const DynamicFlowProvider: ({ loading, children }: Props) => JSX.Element;
+export declare const useDynamicFlow: () => {
+    loading: boolean;
+    registerPersistAsyncPromise: (promise: Promise<unknown>) => void;
+};
+export {};

package/build/common/contexts/dynamicFlowContext/dynamicFlowContext.js

@@ -0,0 +1,36 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { usePendingPromiseCounter } from './usePendingPromiseCounter';
+var defaultContextValue = {
+    loading: false,
+    registerPersistAsyncPromise: function (promise) {
+        //
+    }
+};
+var DFContext = createContext(defaultContextValue);
+export var DynamicFlowProvider = function (_a) {
+    var loading = _a.loading, children = _a.children;
+    var _b = usePendingPromiseCounter(), pendingPromises = _b.pendingPromises, addPendingPromise = _b.addPendingPromise;
+    var providerValue = useMemo(function () {
+        return {
+            loading: loading || pendingPromises > 0,
+            registerPersistAsyncPromise: addPendingPromise
+        };
+    }, [loading, pendingPromises, addPendingPromise]);
+    return _jsx(DFContext.Provider, __assign({ value: providerValue }, { children: children }));
+};
+export var useDynamicFlow = function () {
+    var context = useContext(DFContext);
+    return context || defaultContextValue;
+};

package/build/common/contexts/dynamicFlowContext/usePendingPromiseCounter.d.ts

@@ -0,0 +1,4 @@
+export declare function usePendingPromiseCounter(): {
+    addPendingPromise: (promise: Promise<unknown>) => void;
+    pendingPromises: number;
+};

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

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

package/build/common/contexts/fetcherContext/fetcherContext.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+type Fetcher = typeof fetch;
+type FetcherProviderProps = {
+    fetcher: Fetcher;
+    children: React.ReactNode;
+};
+export declare const FetcherProvider: ({ fetcher, children }: FetcherProviderProps) => JSX.Element;
+type FetcherProviderFromBaseUrlProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+};
+export declare const FetcherProviderFromBaseUrl: ({ baseUrl, children, }: FetcherProviderFromBaseUrlProps) => JSX.Element;
+/**
+ * Provides the fetch(er) function for dynamic flows asynchronous operations.
+ */
+export declare const useFetcher: () => typeof fetch;
+export declare const useHasFetcherProvider: () => boolean;
+export {};

package/build/common/contexts/fetcherContext/fetcherContext.js

@@ -0,0 +1,35 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { makeFetcher } from '.';
+var FetcherContext = createContext(undefined);
+export var FetcherProvider = function (_a) {
+    var fetcher = _a.fetcher, children = _a.children;
+    return _jsx(FetcherContext.Provider, __assign({ value: fetcher }, { children: children }));
+};
+export var FetcherProviderFromBaseUrl = function (_a) {
+    var baseUrl = _a.baseUrl, children = _a.children;
+    var fetcher = useMemo(function () { return makeFetcher(baseUrl); }, [baseUrl]);
+    return _jsx(FetcherContext.Provider, __assign({ value: fetcher }, { children: children }));
+};
+/**
+ * Provides the fetch(er) function for dynamic flows asynchronous operations.
+ */
+export var useFetcher = function () {
+    var contextFetch = useContext(FetcherContext);
+    return contextFetch || fetch;
+};
+export var useHasFetcherProvider = function () {
+    var context = useContext(FetcherContext);
+    return !!context;
+};

package/build/common/contexts/fetcherContext/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fetcherContext';
+export { makeFetcher } from './makeFetcher';

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

@@ -0,0 +1,2 @@
+export * from './fetcherContext';
+export { makeFetcher } from './makeFetcher';

package/build/common/contexts/fetcherContext/makeFetcher.d.ts

@@ -0,0 +1,2 @@
+export type Fetcher = typeof fetch;
+export declare const makeFetcher: (baseUrl: string, additionalHeaders?: HeadersInit) => Fetcher;

package/build/common/contexts/fetcherContext/makeFetcher.js

@@ -0,0 +1,33 @@
+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 { isRelativePath } from '../../api/utils';
+export var makeFetcher = function (baseUrl, additionalHeaders) {
+    return function (input, init) {
+        var resource = applyBaseUrl(input, baseUrl || '');
+        var headers = mergeHeaders(init === null || init === void 0 ? void 0 : init.headers, additionalHeaders);
+        return fetch(resource, __assign(__assign({}, (init || {})), { headers: headers }));
+    };
+};
+var applyBaseUrl = function (input, baseUrl) {
+    return typeof input === 'string' && isRelativePath(input) ? baseUrl + input : input;
+};
+var mergeHeaders = function (initHeaders, additionalHeaders) {
+    if (!initHeaders && !additionalHeaders) {
+        return {};
+    }
+    var headers = new Headers(initHeaders);
+    for (var _i = 0, _a = Object.entries(additionalHeaders || {}); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        headers.set(key, value);
+    }
+    return headers;
+};

package/build/common/general/index.d.ts

@@ -0,0 +1,2 @@
+export declare const dateStringToDate: (dateString: string) => Date | null;
+export declare const dateToDateString: (date: Date) => string;

package/build/common/general/index.js

@@ -0,0 +1,22 @@
+import { isNumber } from '@transferwise/neptune-validation';
+// function taken from: https://stackoverflow.com/questions/23593052/format-javascript-date-as-yyyy-mm-dd
+function formatDate(date) {
+    var d = new Date(date);
+    var month = "".concat(d.getMonth() + 1);
+    var day = "".concat(d.getDate());
+    var year = d.getFullYear();
+    var formattedMonth = month.length < 2 ? "0".concat(month) : month;
+    var formattedDay = day.length < 2 ? "0".concat(day) : day;
+    return [year, formattedMonth, formattedDay].join('-');
+}
+export var dateStringToDate = function (dateString) {
+    if (!dateString) {
+        return null;
+    }
+    var _a = dateString.split('-').map(function (number) { return parseInt(number, 10); }), year = _a[0], month = _a[1], date = _a[2];
+    if (!isNumber(year) || !isNumber(month) || !isNumber(date)) {
+        return null;
+    }
+    return new Date(year, month - 1, date);
+};
+export var dateToDateString = function (date) { return formatDate(date); };

package/build/common/hooks/useDebouncedFunction.d.ts

@@ -0,0 +1,2 @@
+import { DebouncedFunc, DebounceSettings } from 'lodash';
+export declare function useDebouncedFunction<T extends (...args: any[]) => any>(callback: T, delay: number, options?: DebounceSettings): DebouncedFunc<T>;

package/build/common/hooks/useDebouncedFunction.js

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

package/build/common/hooks/useDebouncedFunction.test.d.ts

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

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

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

package/build/common/hooks/usePersistAsync.d.ts

@@ -0,0 +1,7 @@
+import { PersistAsync } from '../../dynamic-flow-types';
+type PersistAsyncModel = string | Blob | null;
+type PerformPersistAsyncFunction = (payload: PersistAsyncModel) => Promise<{
+    data: string | number;
+}>;
+export declare const usePersistAsync: (persistAsync: PersistAsync) => PerformPersistAsyncFunction;
+export {};

package/build/common/hooks/usePersistAsync.js

@@ -0,0 +1,170 @@
+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 { isNull, isObject, isNumber, isString } from '@transferwise/neptune-validation';
+import { useState } from 'react';
+import { useIntl } from 'react-intl';
+import { isBlobSchema } from '../../dynamic-flow-types';
+import messages from '../../jsonSchemaForm/persistAsyncSchema/PersistAsyncSchema.messages';
+import { getErrorFromResponse } from '../../jsonSchemaForm/persistAsyncSchema/basic/PersistAsyncBasicSchema'; // FIXME: extract these functions form that schema component to either here or their own module
+import { useFetcher } from '../contexts/fetcherContext';
+import { isValidSchema } from '../validation/schema-validators';
+export var usePersistAsync = function (persistAsync) {
+    var _a = useState(null), abortController = _a[0], setAbortController = _a[1];
+    var fetcher = useFetcher();
+    var intl = 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 ? !isBlobSchema(schema) : !isValidSchema(model, schema);
+                        if (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 = 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 (isObject(jsonResponse)) {
+                            id = jsonResponse[persistAsync.idProperty];
+                            if (isString(id) || 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 (isObject(jsonResponse)) {
+                            error = getErrorFromResponse(persistAsync.param, jsonResponse);
+                            if (isString(error)) {
+                                throw new Error(error);
+                            }
+                        }
+                        _a.label = 2;
+                    case 2: throw new Error(intl.formatMessage(messages.genericError));
+                }
+            });
+        });
+    }
+    var handleError = function (error) {
+        var message = hasStringMessage(error)
+            ? error.message
+            : intl.formatMessage(messages.genericError);
+        throw new Error(message);
+    };
+    return handlePersistAsync;
+};
+function wrapInFormData(key, value) {
+    var formData = new FormData();
+    if (value !== null) {
+        formData.append(key, value);
+    }
+    return formData;
+}
+function hasStringMessage(value) {
+    return isObject(value) && 'message' in value && typeof value.message === 'string';
+}

package/build/common/hooks/usePolling.d.ts

@@ -0,0 +1,11 @@
+type PollingOptions<PR> = {
+    asyncFn: (() => Promise<PR>) | undefined;
+    interval: number;
+    maxAttempts: number;
+    maxConsecutiveFails: number;
+    onPollingResponse: (pollingResponse: PR) => boolean;
+    onFailure: () => void;
+};
+export declare function usePolling<PollingResponse>({ asyncFn, interval, maxAttempts, maxConsecutiveFails, onPollingResponse, onFailure, }: PollingOptions<PollingResponse>): void;
+export declare function createPollingClosure<PR>(asyncFn: (() => Promise<PR>) | undefined, maxAttempts: number, maxConsecutiveFails: number, onPollingResponse: (pollingResponse: PR) => boolean, onFailure: () => void): () => void;
+export {};

package/build/common/hooks/usePolling.js

@@ -0,0 +1,48 @@
+/* eslint-disable fp/no-mutation */
+import { useEffect, useMemo, useRef } from 'react';
+export function usePolling(_a) {
+    var asyncFn = _a.asyncFn, interval = _a.interval, maxAttempts = _a.maxAttempts, maxConsecutiveFails = _a.maxConsecutiveFails, onPollingResponse = _a.onPollingResponse, onFailure = _a.onFailure;
+    var onPollingResponseReference = useRef(onPollingResponse);
+    var onFailureReference = useRef(onFailure);
+    var poll = useMemo(function () {
+        return createPollingClosure(asyncFn, maxAttempts, maxConsecutiveFails, function (pollingResponse) { return onPollingResponseReference.current(pollingResponse); }, function () { return onFailureReference.current(); });
+    }, [asyncFn, maxAttempts, maxConsecutiveFails]);
+    useEffect(function () {
+        if (interval > 0) {
+            var intervalReference_1 = setInterval(function () {
+                poll();
+            }, interval);
+            return function () { return clearInterval(intervalReference_1); };
+        }
+    }, [poll, interval]);
+    useEffect(function () {
+        onPollingResponseReference.current = onPollingResponse;
+        onFailureReference.current = onFailure;
+    }, [onPollingResponse, onFailure]);
+}
+export function createPollingClosure(asyncFn, maxAttempts, maxConsecutiveFails, onPollingResponse, onFailure) {
+    var isPolling = true;
+    var consecutiveFailures = 0;
+    var attemptCount = 0;
+    return asyncFn
+        ? function () {
+            if (isPolling) {
+                attemptCount++;
+                asyncFn()
+                    .then(function (pollingResponse) {
+                    consecutiveFailures = 0;
+                    isPolling = onPollingResponse(pollingResponse);
+                })["catch"](function () {
+                    consecutiveFailures++;
+                })["finally"](function () {
+                    if (consecutiveFailures >= maxConsecutiveFails || attemptCount >= maxAttempts) {
+                        onFailure();
+                        isPolling = false;
+                    }
+                });
+            }
+        }
+        : function () {
+            //
+        };
+}

package/build/common/hooks/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export default usePrevious;
+declare function usePrevious(value: any): undefined;

package/build/common/hooks/usePrevious.js

@@ -0,0 +1,9 @@
+import { useEffect, useRef } from 'react';
+var usePrevious = function (value) {
+    var reference = useRef();
+    useEffect(function () {
+        reference.current = value;
+    }, [value]);
+    return reference.current;
+};
+export default usePrevious;

package/build/common/index.d.ts

@@ -0,0 +1,4 @@
+export { Size } from './propsValues/size';
+export { DateMode } from './propsValues/dateMode';
+export { MonthFormat } from './propsValues/monthFormat';
+export { FormControlType } from './propsValues/formControlType';

package/build/common/index.js

@@ -0,0 +1,4 @@
+export { Size } from './propsValues/size';
+export { DateMode } from './propsValues/dateMode';
+export { MonthFormat } from './propsValues/monthFormat';
+export { FormControlType } from './propsValues/formControlType';

package/build/common/logging/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+export type LogLevel = 'debug' | 'info' | 'warning' | 'error' | 'critical';
+export type LogTitle = 'Invalid schema or model' | 'Invalid model on change' | 'Invalid response' | 'Action supressed' | 'Deprecation advanced warning' | 'Deprecated schema' | 'Error fetching';
+type ExtraProps = Record<string, unknown>;
+export type LogEventHandler = (level: LogLevel, message: string, extra: ExtraProps) => void;
+type LogFunction = (title: LogTitle, description: string, extra?: ExtraProps) => void;
+export declare const getLogger: (level: LogLevel, onLog: LogEventHandler, flowId?: string | undefined, stepId?: string | undefined) => LogFunction;
+type LogProviderProps = {
+    flowId?: string;
+    stepId?: string;
+    children: React.ReactNode;
+    onLog: LogEventHandler;
+};
+export declare const LogProvider: ({ flowId, stepId, children, onLog }: LogProviderProps) => JSX.Element;
+export declare const useLogger: () => {
+    debug: LogFunction;
+    info: LogFunction;
+    warning: LogFunction;
+    error: LogFunction;
+    critical: LogFunction;
+};
+export {};

package/build/common/logging/index.js

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

package/build/common/logging/spec.d.ts

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