@wise/dynamic-flow-client 3.11.2 → 3.11.4-experiment-node20-aa45bc2

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

@@ -0,0 +1,221 @@
+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 { act, waitFor } from '@testing-library/react';
+import { renderHook } from '@testing-library/react-hooks';
+import { usePersistAsync } from './usePersistAsync';
+import { useHttpClient } from '../../../../common/httpClientContext';
+jest.mock('react-intl', function () { return (__assign(__assign({}, jest.requireActual('react-intl')), { useIntl: jest.fn(function () { return ({
+        formatMessage: jest.fn(function (message) { return message; }),
+    }); }), defineMessages: jest.fn(function (errorMessages) {
+        var translatedErrors = {};
+        // eslint-disable-next-line guard-for-in
+        for (var errorKey in errorMessages) {
+            translatedErrors[errorKey] = errorMessages[errorKey].defaultMessage;
+        }
+        return translatedErrors;
+    }) })); });
+jest.mock('../../../../common/httpClientContext');
+describe('usePersistAsync hook', function () {
+    var idProperty = 'responseKey';
+    var param = 'bodyAttribute';
+    var schema = {
+        url: 'http://localhost:3001/v1/save-file/',
+        method: 'POST',
+        param: param,
+        idProperty: idProperty,
+        schema: {
+            type: 'string',
+            format: 'base64url',
+        },
+    };
+    var mockHttpClient = jest.fn();
+    beforeEach(function () {
+        useHttpClient.mockImplementation(function () { return mockHttpClient; });
+    });
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    describe('when invoked with persist async schema for a file', function () {
+        it('should validate the passed value if null and return a rejected promise', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result, handlePersistAsync;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = renderHook(function () { return usePersistAsync(schema); }).result;
+                        handlePersistAsync = result.current;
+                        return [4 /*yield*/, expect(handlePersistAsync(null)).rejects.toThrow({
+                                message: 'Something went wrong, please try again.',
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should validate the passed value if not as per schema and return a rejected promise', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result, handlePersistAsync;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = renderHook(function () { return usePersistAsync(schema); }).result;
+                        handlePersistAsync = result.current;
+                        return [4 /*yield*/, expect(handlePersistAsync([])).rejects.toThrow({
+                                message: 'Something went wrong, please try again.',
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should make an API request as per the passed schema specs, with base64 json body upload approach', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result, handlePersistAsync;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        mockHttpClient.mockResolvedValue({
+                            ok: true,
+                            status: 200,
+                            json: jest.fn().mockResolvedValue((_a = {}, _a[idProperty] = 'savedFileId', _a)),
+                        });
+                        result = renderHook(function () { return usePersistAsync(schema); }).result;
+                        handlePersistAsync = result.current;
+                        return [4 /*yield*/, act(function () { return handlePersistAsync('some string'); })];
+                    case 1:
+                        _b.sent();
+                        expect(mockHttpClient).toHaveBeenCalledWith('http://localhost:3001/v1/save-file/', {
+                            body: "{\"".concat(param, "\":\"some string\"}"),
+                            headers: { 'Content-Type': 'application/json' },
+                            method: 'POST',
+                            signal: expect.any(AbortSignal),
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should make an API request as per the passed schema specs, with blob type schemas', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var blobSchema, result, handlePersistAsync, dummyUserInput;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        mockHttpClient.mockResolvedValue({
+                            ok: true,
+                            status: 200,
+                            json: jest.fn().mockResolvedValue((_a = {}, _a[idProperty] = 'savedFileId', _a)),
+                        });
+                        blobSchema = __assign(__assign({}, schema), { schema: {
+                                type: 'blob',
+                            } });
+                        result = renderHook(function () { return usePersistAsync(blobSchema); }).result;
+                        handlePersistAsync = result.current;
+                        dummyUserInput = new File([], 'test-file');
+                        return [4 /*yield*/, act(function () { return handlePersistAsync(dummyUserInput); })];
+                    case 1:
+                        _b.sent();
+                        expect(mockHttpClient).toHaveBeenCalledWith('http://localhost:3001/v1/save-file/', {
+                            body: expect.any(FormData),
+                            headers: {},
+                            method: 'POST',
+                            signal: expect.any(AbortSignal),
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should make an API request and on invalid value response from backend, should return appropriate error', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var UNPROCESSABLE_ENTITY_HTTP_STATUS_CODE, validationError, stringSchema, result, handlePersistAsync;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        UNPROCESSABLE_ENTITY_HTTP_STATUS_CODE = 422;
+                        validationError = 'We need a dog, not a mock';
+                        mockHttpClient.mockResolvedValue({
+                            ok: false,
+                            status: UNPROCESSABLE_ENTITY_HTTP_STATUS_CODE,
+                            json: jest.fn().mockResolvedValue({ validation: (_a = {}, _a[param] = validationError, _a) }),
+                        });
+                        stringSchema = __assign(__assign({}, schema), { schema: {
+                                type: 'string',
+                            } });
+                        result = renderHook(function () { return usePersistAsync(stringSchema); }).result;
+                        handlePersistAsync = result.current;
+                        return [4 /*yield*/, waitFor(function () {
+                                return expect(handlePersistAsync('fileBase64String')).rejects.toThrow({
+                                    message: validationError,
+                                });
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should make an API request and if unable to reach server/no network should throw Generic error', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result, handlePersistAsync;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockHttpClient.mockRejectedValue();
+                        result = renderHook(function () { return usePersistAsync(schema); }).result;
+                        handlePersistAsync = result.current;
+                        return [4 /*yield*/, waitFor(function () {
+                                return expect(handlePersistAsync('fileBase64String')).rejects.toThrow({
+                                    message: 'Something went wrong, please try again.',
+                                });
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

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

@@ -0,0 +1,53 @@
+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]);
+    // eslint-disable-next-line consistent-return
+    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 (error) {
+                    // do not fail on network errors
+                    if (error.message !== 'network failed') {
+                        consecutiveFailures += 1;
+                    }
+                })
+                    .finally(function () {
+                    if (consecutiveFailures >= maxConsecutiveFails || attemptCount >= maxAttempts) {
+                        onFailure();
+                        isPolling = false;
+                    }
+                });
+            }
+        }
+        : function () {
+            //
+        };
+}

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

@@ -0,0 +1,243 @@
+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 { createPollingClosure } from './usePolling';
+describe('usePolling', function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+    });
+    describe('when the async function resolves', function () {
+        var asyncFn = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, 'result'];
+        }); }); });
+        var onFail = jest.fn();
+        it('calls the onPollingResponse callback', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var onPollingResponse, poll;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        onPollingResponse = jest.fn();
+                        poll = createPollingClosure(asyncFn, 100, 3, onPollingResponse, onFail);
+                        poll();
+                        return [4 /*yield*/, waitFor(function () {
+                                expect(onPollingResponse).toHaveBeenLastCalledWith('result');
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        describe('and the onPollingRespnse callback returns true', function () {
+            var onPollingResponse = jest.fn(function () { return true; });
+            it('keeps polling', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var poll;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            poll = createPollingClosure(asyncFn, 10, 3, onPollingResponse, onFail);
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(1); })];
+                        case 1:
+                            _a.sent();
+                            poll();
+                            poll();
+                            poll();
+                            expect(asyncFn).toHaveBeenCalledTimes(4);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('calls onFail if the maxAttemps value is reached, and it stops polling', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var poll;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            poll = createPollingClosure(asyncFn, 6, 3, onPollingResponse, onFail);
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(1); })];
+                        case 1:
+                            _a.sent();
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(2); })];
+                        case 2:
+                            _a.sent();
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(3); })];
+                        case 3:
+                            _a.sent();
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(4); })];
+                        case 4:
+                            _a.sent();
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(5); })];
+                        case 5:
+                            _a.sent();
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(6); })];
+                        case 6:
+                            _a.sent();
+                            return [4 /*yield*/, waitFor(function () { return expect(asyncFn).toHaveBeenCalledTimes(6); })];
+                        case 7:
+                            _a.sent();
+                            return [4 /*yield*/, waitFor(function () { return expect(onFail).toHaveBeenCalledTimes(1); })];
+                        case 8:
+                            _a.sent();
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).not.toHaveBeenCalledTimes(7); })];
+                        case 9:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        describe('and the onPollingRespnse callback returns false', function () {
+            var onPollingResponse = jest.fn(function () { return false; });
+            it('stops polling', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var poll;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            poll = createPollingClosure(asyncFn, 100, 3, onPollingResponse, onFail);
+                            poll();
+                            return [4 /*yield*/, waitFor(function () { return expect(onPollingResponse).toHaveBeenCalledTimes(1); })];
+                        case 1:
+                            _a.sent();
+                            poll();
+                            poll();
+                            poll();
+                            poll();
+                            expect(asyncFn).toHaveBeenCalledTimes(1);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    describe('when the async function rejects enough consecutive times', function () {
+        var asyncFn = jest.fn();
+        var onFail = jest.fn();
+        it('calls the onFail callback', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var onPollingResponse, poll;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        onPollingResponse = jest.fn(function () { return true; });
+                        poll = createPollingClosure(asyncFn, 100, 3, onPollingResponse, onFail);
+                        asyncFn.mockRejectedValueOnce(Error('failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 1:
+                        _a.sent();
+                        asyncFn.mockRejectedValueOnce(Error('failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 2:
+                        _a.sent();
+                        asyncFn.mockResolvedValueOnce('✅ ok');
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 3:
+                        _a.sent();
+                        asyncFn.mockRejectedValueOnce(Error('failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 4:
+                        _a.sent();
+                        asyncFn.mockRejectedValueOnce(Error('failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 5:
+                        _a.sent();
+                        asyncFn.mockRejectedValueOnce(Error('failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).toHaveBeenCalledTimes(1); })];
+                    case 6:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when the async function does not resolve (e.g. a network error)', function () {
+        var asyncFn = jest.fn();
+        var onFail = jest.fn();
+        var onPollingResponse = jest.fn(function () { return true; });
+        it('does not call the onFail callback', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var poll;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        poll = createPollingClosure(asyncFn, 5, 1, onPollingResponse, onFail);
+                        asyncFn.mockRejectedValueOnce(Error('network failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('increments the attempt counter', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var poll;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        poll = createPollingClosure(asyncFn, 3, 1, onPollingResponse, onFail);
+                        asyncFn.mockRejectedValueOnce(Error('network failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 1:
+                        _a.sent();
+                        asyncFn.mockRejectedValueOnce(Error('network failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).not.toHaveBeenCalled(); })];
+                    case 2:
+                        _a.sent();
+                        asyncFn.mockRejectedValueOnce(Error('network failed'));
+                        poll();
+                        return [4 /*yield*/, waitFor(function () { return expect(onFail).toHaveBeenCalledTimes(1); })];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

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

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

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

@@ -0,0 +1,66 @@
+import { renderHook } from '@testing-library/react-hooks';
+import { usePrevious } from './usePrevious';
+describe('when usePrev is used', function () {
+    var value;
+    var rerender;
+    describe('when used with primitive', function () {
+        beforeEach(function () {
+            var view = renderHook(function (_a) {
+                var state = _a.state;
+                return usePrevious(state);
+            }, { initialProps: { state: 0 } });
+            value = view.result;
+            rerender = view.rerender;
+        });
+        it('should be undefined initially', function () {
+            expect(value.current).toBeUndefined();
+        });
+        describe('when value is updated', function () {
+            beforeEach(function () {
+                rerender({ state: 1 });
+            });
+            it('should return previous value', function () {
+                expect(value.current).toBe(0);
+            });
+            describe('when value is updated again', function () {
+                beforeEach(function () {
+                    rerender({ state: 1 });
+                });
+                it('should still render previous value', function () {
+                    expect(value.current).toBe(1);
+                });
+            });
+        });
+    });
+    describe('when used with object', function () {
+        beforeEach(function () {
+            var view = renderHook(function (_a) {
+                var state = _a.state;
+                return usePrevious(state);
+            }, {
+                initialProps: { state: { foo: 'bar' } },
+            });
+            value = view.result;
+            rerender = view.rerender;
+        });
+        it('should be undefined initially', function () {
+            expect(value.current).toBeUndefined();
+        });
+        describe('when value is updated', function () {
+            beforeEach(function () {
+                rerender({ state: { foo: 'foo' } });
+            });
+            it('should return previous value', function () {
+                expect(value.current).toMatchObject({ foo: 'bar' });
+            });
+            describe('when value is updated again', function () {
+                beforeEach(function () {
+                    rerender({ foo: 'foo' });
+                });
+                it('should still render previous value', function () {
+                    expect(value.current).toMatchObject({ foo: 'foo' });
+                });
+            });
+        });
+    });
+});

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

@@ -0,0 +1,45 @@
+import { useCallback, useMemo } from 'react';
+import { usePolling } from '..';
+import { useHttpClient } from '../../../../common/httpClientContext';
+export function useStepPolling(polling, onAction) {
+    var httpClient = useHttpClient();
+    var asyncFn = useMemo(function () {
+        if (polling) {
+            return function () {
+                return httpClient(polling.url)
+                    .then(function (response) {
+                    if (response.ok) {
+                        return response
+                            .json()
+                            .then(function (pollingResponse) { return pollingResponse; })
+                            .catch(function (error) { return null; });
+                    }
+                    throw new Error('failed');
+                })
+                    .catch(function (error) {
+                    throw new Error(error.message === 'failed' ? 'failed' : 'network failed');
+                });
+            };
+        }
+        return undefined;
+    }, [polling, httpClient]);
+    var onPollingResponse = useCallback(function (pollingResponse) {
+        if (pollingResponse === null || pollingResponse === void 0 ? void 0 : pollingResponse.action) {
+            onAction(pollingResponse.action);
+            return false; // stop polling
+        }
+        return true; // continue polling
+    }, [onAction]);
+    usePolling({
+        asyncFn: asyncFn,
+        interval: 1000 * ((polling === null || polling === void 0 ? void 0 : polling.interval) || 0),
+        maxAttempts: (polling === null || polling === void 0 ? void 0 : polling.maxAttempts) || 0,
+        maxConsecutiveFails: 1,
+        onPollingResponse: onPollingResponse,
+        onFailure: useCallback(function () {
+            if (polling) {
+                onAction(polling.onError.action);
+            }
+        }, [onAction, polling]),
+    });
+}