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

package/build/revamp/domain/components/utils/file-utils.spec.js

@@ -0,0 +1,81 @@
+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 };
+    }
+};
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { base64dataUrltoFile, toBase64 } from './file-utils';
+describe('toBase64', function () {
+    describe('given a valid file', function () {
+        it('should return a base64 string', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var file;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        file = new File(['hello'], 'test.txt', { type: 'text/plain' });
+                        return [4 /*yield*/, expect(toBase64(file)).resolves.toBe('data:text/plain;base64,aGVsbG8=')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+describe('dataURLtoFile', function () {
+    describe('given a valid data URL', function () {
+        var dataurl = 'data:text/plain;base64,aGVsbG8=';
+        it('should return a file that can be encoded back to the given string', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var file;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        file = base64dataUrltoFile(dataurl, 'test.txt');
+                        expect(file).toBeInstanceOf(File);
+                        expect(file.type).toBe('text/plain');
+                        expect(file.name).toBe('test.txt');
+                        return [4 /*yield*/, expect(toBase64(file)).resolves.toBe(dataurl)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('given an invalid data URL', function () {
+        it('should return null', function () {
+            expect(base64dataUrltoFile('invalid', 'test.txt')).toBeNull();
+        });
+    });
+});

package/build/revamp/domain/components/utils/getComponentForLocalValueKey.js

@@ -0,0 +1,31 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { hasChildren, isObjectLocalValue } from '../../../utils/type-utils';
+/**
+ * Returns a component that is a child (or grandchild, etc.) of the given component,
+ * which is "responsible" for the value of the given key,
+ * or null if there isn't any.
+ */
+export var getComponentForLocalValueKey = function (key, component) {
+    if (component.type === 'object') {
+        return component.componentMap[key];
+    }
+    if (component.type === 'select') {
+        var selectedChild = component.getSelectedChild();
+        return selectedChild ? getComponentForLocalValueKey(key, selectedChild) : null;
+    }
+    var child = hasChildren(component)
+        ? __spreadArray([], component.getChildren(), true).reverse().find(function (c) {
+            var v = c.getLocalValue();
+            return isObjectLocalValue(v) && key in v;
+        })
+        : undefined;
+    return child ? getComponentForLocalValueKey(key, child) : null;
+};

package/build/revamp/domain/components/utils/isPartialLocalValueMatch.js

@@ -0,0 +1,46 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { isObjectLocalValue } from '../../../utils/type-utils';
+import { isNullish } from '../../../utils/type-validators';
+import { getComponentForLocalValueKey } from './getComponentForLocalValueKey';
+import { compareLocalValue } from './local-value';
+export var isPartialLocalValueMatch = function (partialValue, component) {
+    if (!component) {
+        return false;
+    }
+    var componentValue = component.getLocalValue();
+    if (component.type === 'const') {
+        return compareLocalValue(partialValue, componentValue);
+    }
+    if (isObjectLocalValue(partialValue) && isObjectLocalValue(componentValue)) {
+        return isPartialObjectMatch(partialValue, componentValue, component);
+    }
+    // TODO: Handle tuples, when supported.
+    return null;
+};
+var isPartialObjectMatch = function (partialValue, componentValue, component) {
+    var results = getMatchingKeys(partialValue, componentValue).map(function (key) {
+        var componentForKey = getComponentForLocalValueKey(key, component);
+        return componentForKey && componentForKey.type === 'const'
+            ? isPartialLocalValueMatch(partialValue[key], componentForKey)
+            : null;
+    });
+    if (results.includes(false)) {
+        return false;
+    }
+    if (results.includes(true)) {
+        return true;
+    }
+    return null;
+};
+var getMatchingKeys = function (a, b) {
+    var allKeys = Array.from(new Set(__spreadArray(__spreadArray([], Object.keys(a), true), Object.keys(b), true)));
+    return allKeys.filter(function (key) { return !isNullish(a[key]) && !isNullish(b[key]); });
+};

package/build/revamp/domain/components/utils/isPartialLocalValueMatch.spec.js

@@ -0,0 +1,125 @@
+import { isPartialLocalValueMatch } from './isPartialLocalValueMatch';
+var makeConstComponent = function (value) {
+    return ({
+        type: 'const',
+        getLocalValue: function () { return value; },
+    });
+};
+describe('isPartialLocalValueMatch', function () {
+    describe('when the component type is "const"', function () {
+        it('should return false if values are different (object)', function () {
+            expect(isPartialLocalValueMatch({ some: 'value' }, makeConstComponent({ some: 'other-value' }))).toBe(false);
+        });
+        it('should return false if values are different (array)', function () {
+            expect(isPartialLocalValueMatch(['aaa', 'bbb'], makeConstComponent(['aaa', 'bbb', 'ccc']))).toBe(false);
+        });
+        it('should return true if primitive values are identical', function () {
+            expect(isPartialLocalValueMatch(1234, makeConstComponent(1234))).toBe(true);
+        });
+        it('should return true if boolean values are identical', function () {
+            expect(isPartialLocalValueMatch(false, makeConstComponent(false))).toBe(true);
+        });
+        it('should return true if object values are identical', function () {
+            expect(isPartialLocalValueMatch({ a: 'aaa', b: 111 }, makeConstComponent({ a: 'aaa', b: 111 }))).toBe(true);
+        });
+        it('should return true if array values are identical', function () {
+            expect(isPartialLocalValueMatch(['aaa', 'bbb'], makeConstComponent(['aaa', 'bbb']))).toBe(true);
+        });
+        it('should return true if empty-object values are identical', function () {
+            expect(isPartialLocalValueMatch({}, makeConstComponent({}))).toBe(true);
+        });
+    });
+    describe('when the component type is NOT "const"', function () {
+        var objectComponent = {
+            type: 'object',
+            componentMap: {
+                type: {
+                    type: 'const',
+                    getLocalValue: function () { return 'SOME-VALUE'; },
+                },
+                other: {
+                    type: 'string',
+                    getLocalValue: function () { return 'some string'; },
+                },
+            },
+            getLocalValue: function () { return ({
+                type: 'SOME-VALUE',
+                other: 'some string',
+            }); },
+        };
+        describe('when the component type is "object"', function () {
+            it('should return true if one matching constant value is present', function () {
+                expect(isPartialLocalValueMatch({ type: 'SOME-VALUE' }, objectComponent)).toBe(true);
+            });
+            it('should return false if one mismatching constant value is present', function () {
+                expect(isPartialLocalValueMatch({ type: 'OTHER-VALUE' }, objectComponent)).toBe(false);
+            });
+            it('should return null if NO matching constant value is present', function () {
+                expect(isPartialLocalValueMatch({}, objectComponent)).toBeNull();
+            });
+            it('should return null when some other non-const property matches', function () {
+                expect(isPartialLocalValueMatch({ other: 'some string' }, objectComponent)).toBeNull();
+            });
+        });
+        describe('when the component type is "all-of"', function () {
+            var allofComponent = {
+                type: 'all-of',
+                getChildren: function () { return [objectComponent]; },
+                getLocalValue: function () { return objectComponent.getLocalValue(); },
+            };
+            it('should return true if one matching constant value is present', function () {
+                expect(isPartialLocalValueMatch({ type: 'SOME-VALUE' }, allofComponent)).toBe(true);
+            });
+            it('should return false if one mismatching constant value is present', function () {
+                expect(isPartialLocalValueMatch({ type: 'OTHER-VALUE' }, allofComponent)).toBe(false);
+            });
+            it('should return null if NO matching constant value is present', function () {
+                expect(isPartialLocalValueMatch({}, allofComponent)).toBeNull();
+            });
+        });
+    });
+    describe('when the local value is a File instance', function () {
+        it('should return null, when comparing files (with persist-async)', function () {
+            var localValue = new File(['ABCD'], 'a.txt', { type: 'text/plain' });
+            var componentB = {
+                isPersisted: true,
+                getLocalValue: function () { return 'it doesnt matter what the value is'; },
+            };
+            expect(isPartialLocalValueMatch(localValue, componentB)).toBeNull();
+        });
+        it('should return null, when comparing files (base64url string)', function () {
+            var localValue = new File(['ABCD'], 'a.txt', { type: 'text/plain' });
+            var componentB = {
+                type: 'upload',
+                getLocalValue: function () {
+                    return new File(['it doesnt matter'], 'irrelevant.png', { type: 'image/png' });
+                },
+            };
+            expect(isPartialLocalValueMatch(localValue, componentB)).toBeNull();
+        });
+    });
+    describe('when the local value is an array and the component is "repeatable"', function () {
+        it('should return null, even with different elements', function () {
+            var localValue = ['a', 'b', 'c'];
+            var componentB = {
+                type: 'repeatable',
+                getLocalValue: function () { return ['d', 'e', 'f', 'g']; },
+            };
+            expect(isPartialLocalValueMatch(localValue, componentB)).toBeNull();
+        });
+    });
+    describe('when the local value is an array and the component is "multi-upload"', function () {
+        var fileA = new File(['A'], 'a.txt', { type: 'text/plain' });
+        var fileB = new File(['B'], 'b.txt', { type: 'text/plain' });
+        var fileC = new File(['C'], 'c.txt', { type: 'text/plain' });
+        var fileD = new File(['D'], 'd.txt', { type: 'text/plain' });
+        it('should return null, even with different elements', function () {
+            var localValue = [fileA, fileB];
+            var componentB = {
+                type: 'multi-upload',
+                getLocalValue: function () { return [fileC, fileD]; },
+            };
+            expect(isPartialLocalValueMatch(localValue, componentB)).toBeNull();
+        });
+    });
+});

package/build/revamp/domain/components/utils/local-value.js

@@ -0,0 +1,14 @@
+import { isArrayLocalValue, isObjectLocalValue } from '../../../utils/type-utils';
+export var compareLocalValue = function (valueA, valueB) {
+    if (isArrayLocalValue(valueA) && isArrayLocalValue(valueB)) {
+        return (valueA.length === valueB.length &&
+            valueA.every(function (value, index) { return compareLocalValue(value, valueB[index]); }));
+    }
+    if (isObjectLocalValue(valueA) && isObjectLocalValue(valueB)) {
+        var keysA = Object.keys(valueA);
+        var keysB = Object.keys(valueB);
+        return (keysA.length === keysB.length &&
+            keysA.every(function (key) { return compareLocalValue(valueA[key], valueB[key]); }));
+    }
+    return valueA === valueB;
+};

package/build/revamp/domain/features/events.js

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

package/build/revamp/domain/features/persistAsync/getComponentPersistAsync.js

@@ -0,0 +1,134 @@
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { isNullish } from '../../../utils/type-validators';
+import { abortAndResetController } from '../utils/http-utils';
+import { compareLocalValue } from '../../components/utils/local-value';
+/**
+ * Creates an onPersistAsync handler for a component.
+ */
+export var getComponentPersistAsync = function (update, performPersistAsync) {
+    /**
+     * Will update the persistedState when a new request is made, and will update
+     * the value or set errors when the request completes.
+     */
+    return function (persistedState, currentValue) { return __awaiter(void 0, void 0, void 0, function () {
+        var abortController, lastSubmitted, submission, newAbortController, resolvedNull_1, signal, newSubmission;
+        return __generator(this, function (_a) {
+            abortController = persistedState.abortController, lastSubmitted = persistedState.lastSubmitted, submission = persistedState.submission;
+            // Ignore subsequent requests for the same value
+            if (compareLocalValue(lastSubmitted, currentValue)) {
+                return [2 /*return*/, submission];
+            }
+            newAbortController = abortAndResetController(abortController);
+            if (isNullish(currentValue)) {
+                resolvedNull_1 = Promise.resolve(null);
+                update(function (draft) {
+                    draft.persistedState.abortController = newAbortController;
+                    draft.persistedState.lastSubmitted = currentValue;
+                    draft.persistedState.submission = resolvedNull_1;
+                });
+                return [2 /*return*/, resolvedNull_1];
+            }
+            signal = newAbortController.signal;
+            newSubmission = performPersistAsync({ value: currentValue, signal: signal }).catch(function (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    // No op, the request was aborted
+                    return null;
+                }
+                update(function (draft) {
+                    draft.errors = [error.message];
+                    draft.persistedState.lastSubmitted = null;
+                });
+                throw error;
+            });
+            update(function (draft) {
+                draft.persistedState = {
+                    abortController: newAbortController,
+                    lastSubmitted: currentValue,
+                    submission: newSubmission,
+                };
+            });
+            return [2 /*return*/, newSubmission];
+        });
+    }); };
+};
+/**
+ * Creates an onPersistAsync handler for a component.
+ */
+export var getComponentMultiPersistAsync = function (update, performPersistAsync) {
+    /**
+     * Will update the persistedState when a new request is made, and will update
+     * the value or set errors when the request completes.
+     */
+    return function (value, id) { return __awaiter(void 0, void 0, void 0, function () {
+        var newAbortController, signal, newSubmission;
+        return __generator(this, function (_a) {
+            if (isNullish(value)) {
+                throw new Error('Value must be a file or base64 string.');
+            }
+            newAbortController = new AbortController();
+            signal = newAbortController.signal;
+            newSubmission = performPersistAsync({ value: value, signal: signal }).catch(function (error) {
+                update(function (draft) {
+                    // The file was not persisted, so delete it
+                    draft.persistedState = draft.persistedState.filter(function (state) { return state.id !== id; });
+                });
+                throw error;
+            });
+            update(function (draft) {
+                draft.persistedState = __spreadArray(__spreadArray([], draft.persistedState, true), [
+                    {
+                        id: id,
+                        abortController: newAbortController,
+                        lastSubmitted: null,
+                        submission: newSubmission,
+                    },
+                ], false);
+            });
+            return [2 /*return*/, newSubmission];
+        });
+    }); };
+};

package/build/revamp/domain/features/persistAsync/getComponentPersistAsync.spec.js

@@ -0,0 +1,200 @@
+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 { abortableDelay } from '../../../../test-utils/fetch-utils';
+import { createTextInputComponent, } from '../../components/TextInputComponent';
+import { getInputUpdateFunction } from '../../components/utils/component-utils';
+import { getUpdateFunctionMock } from '../../mappers/schema/tests/test-utils';
+import { getInitialValidationState } from '../validationAsync/getInitialValidationState';
+import { getComponentPersistAsync } from './getComponentPersistAsync';
+import { getInitialPersistedState } from './getInitialPersistedState';
+var defaultProps = {
+    uid: '123',
+    checks: [],
+    analyticsId: 'analyticsId',
+    autoComplete: 'off',
+    disabled: true,
+    errors: [],
+    hidden: false,
+    id: 'id',
+    required: false,
+    persistedState: getInitialPersistedState(),
+    validationState: getInitialValidationState(),
+    value: '',
+    performValidationAsync: undefined,
+    performRefresh: undefined,
+    onValueChange: function () { },
+    summariser: function () { return ({}); },
+};
+describe('getComponentPersistAsync', function () {
+    it('should call update function with the correct arguments', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var performPersistAsync, mockUpdateFunction, inputComponent, update, onPersistAsync, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    performPersistAsync = jest.fn().mockResolvedValue('response');
+                    mockUpdateFunction = getUpdateFunctionMock(function () { return inputComponent; });
+                    inputComponent = createTextInputComponent(__assign(__assign({}, defaultProps), { performPersistAsync: performPersistAsync, value: 'test' }), mockUpdateFunction);
+                    update = getInputUpdateFunction('uid', mockUpdateFunction);
+                    onPersistAsync = getComponentPersistAsync(update, performPersistAsync);
+                    void onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue());
+                    expect(performPersistAsync).toHaveBeenCalledWith(expect.objectContaining({ value: 'test' }));
+                    _a = expect;
+                    return [4 /*yield*/, inputComponent.getSubmittableValue()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toBe('response');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not perform a persist async if called with the same value twice', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var performPersistAsync, mockUpdateFunction, inputComponent, update, onPersistAsync;
+        return __generator(this, function (_a) {
+            performPersistAsync = jest.fn().mockResolvedValue('response');
+            mockUpdateFunction = getUpdateFunctionMock(function () { return inputComponent; });
+            inputComponent = createTextInputComponent(__assign(__assign({}, defaultProps), { performPersistAsync: performPersistAsync, value: 'test' }), mockUpdateFunction);
+            update = getInputUpdateFunction('uid', mockUpdateFunction);
+            onPersistAsync = getComponentPersistAsync(update, performPersistAsync);
+            void onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue());
+            void onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue());
+            expect(performPersistAsync).toHaveBeenCalledTimes(1);
+            return [2 /*return*/];
+        });
+    }); });
+    it('should clear persisted value if value is cleared', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var performPersistAsync, mockUpdateFunction, inputComponent, update, onPersistAsync, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    performPersistAsync = jest.fn().mockResolvedValue('response');
+                    mockUpdateFunction = getUpdateFunctionMock(function () { return inputComponent; });
+                    inputComponent = createTextInputComponent(__assign(__assign({}, defaultProps), { performPersistAsync: performPersistAsync, value: 'test' }), mockUpdateFunction);
+                    update = getInputUpdateFunction('uid', mockUpdateFunction);
+                    onPersistAsync = getComponentPersistAsync(update, performPersistAsync);
+                    void onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue());
+                    _a = expect;
+                    return [4 /*yield*/, inputComponent.getSubmittableValue()];
+                case 1:
+                    _a.apply(void 0, [_c.sent()]).toBe('response');
+                    inputComponent.onChange(null);
+                    void onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue());
+                    _b = expect;
+                    return [4 /*yield*/, inputComponent.getSubmittableValue()];
+                case 2:
+                    _b.apply(void 0, [_c.sent()]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should set component errors if persist async fails', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var performPersistAsync, mockUpdateFunction, inputComponent, update, onPersistAsync;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    performPersistAsync = jest.fn().mockRejectedValue(new Error('error message'));
+                    mockUpdateFunction = getUpdateFunctionMock(function () { return inputComponent; });
+                    inputComponent = createTextInputComponent(__assign(__assign({}, defaultProps), { performPersistAsync: performPersistAsync, value: 'test' }), mockUpdateFunction);
+                    update = getInputUpdateFunction('uid', mockUpdateFunction);
+                    onPersistAsync = getComponentPersistAsync(update, performPersistAsync);
+                    return [4 /*yield*/, expect(onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue())).rejects.toThrow('error message')];
+                case 1:
+                    _a.sent();
+                    expect(inputComponent.errors).toStrictEqual(['error message']);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should ignore previous responses if a second persist has been triggered', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var performPersistAsync, mockUpdateFunction, inputComponent, update, onPersistAsync, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    jest.useFakeTimers();
+                    performPersistAsync = jest
+                        .fn()
+                        .mockImplementationOnce(function (_a) {
+                        var signal = _a.signal;
+                        return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_b) {
+                            return [2 /*return*/, abortableDelay(200, signal).then(function () { return 'response-1'; })];
+                        }); });
+                    })
+                        .mockImplementationOnce(function (_a) {
+                        var signal = _a.signal;
+                        return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_b) {
+                            return [2 /*return*/, abortableDelay(10, signal).then(function () { return 'response-2'; })];
+                        }); });
+                    });
+                    mockUpdateFunction = getUpdateFunctionMock(function () { return inputComponent; });
+                    inputComponent = createTextInputComponent(__assign(__assign({}, defaultProps), { performPersistAsync: performPersistAsync, value: 'test' }), mockUpdateFunction);
+                    update = getInputUpdateFunction('uid', mockUpdateFunction);
+                    onPersistAsync = getComponentPersistAsync(update, performPersistAsync);
+                    void onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue());
+                    inputComponent.onChange('new-value');
+                    void onPersistAsync(inputComponent.persistedState, inputComponent.getLocalValue());
+                    // Second callback has resolved
+                    return [4 /*yield*/, jest.advanceTimersByTimeAsync(100)];
+                case 1:
+                    // Second callback has resolved
+                    _c.sent();
+                    _a = expect;
+                    return [4 /*yield*/, inputComponent.getSubmittableValue()];
+                case 2:
+                    _a.apply(void 0, [_c.sent()]).toBe('response-2');
+                    // First callback has resolved, but value is ignored
+                    return [4 /*yield*/, jest.advanceTimersByTimeAsync(100)];
+                case 3:
+                    // First callback has resolved, but value is ignored
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, inputComponent.getSubmittableValue()];
+                case 4:
+                    _b.apply(void 0, [_c.sent()]).toBe('response-2');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/revamp/domain/features/persistAsync/getInitialPersistedState.js

@@ -0,0 +1,6 @@
+import { isNullish } from '../../../utils/type-validators';
+export var getInitialPersistedState = function (lastSubmitted, model) { return ({
+    abortController: new AbortController(),
+    lastSubmitted: !isNullish(model) ? lastSubmitted !== null && lastSubmitted !== void 0 ? lastSubmitted : null : null,
+    submission: Promise.resolve(model !== null && model !== void 0 ? model : null),
+}); };