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

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

@@ -1,81 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

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

@@ -1,134 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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),
-}); };