@wise/dynamic-flow-client 3.4.1 → 3.5.0-experimental-6654c72

package/build/revamp/domain/components/repeatableComponent/RepeatableComponent.js

@@ -0,0 +1,148 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+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 { validateComponents, getLocalValueValidator, } from '../../features/validation/validation-functions';
+import { getInputUpdateFunction } from '../utils/component-utils';
+export var createRepeatableComponent = function (repeatableProps, updateComponent) {
+    var uid = repeatableProps.uid, id = repeatableProps.id, checks = repeatableProps.checks, components = repeatableProps.components, summary = repeatableProps.summary, createEditableComponent = repeatableProps.createEditableComponent, summariser = repeatableProps.summariser, componentProps = __rest(repeatableProps, ["uid", "id", "checks", "components", "summary", "createEditableComponent", "summariser"]);
+    var update = getInputUpdateFunction(uid, updateComponent);
+    var getValidationErrors = getLocalValueValidator(checks);
+    return __assign(__assign({ uid: uid, id: id, type: 'repeatable', components: components, editableComponent: null, editableIndex: null, summaryDefaults: {
+            title: summary === null || summary === void 0 ? void 0 : summary.defaultTitle,
+            description: summary === null || summary === void 0 ? void 0 : summary.defaultDescription,
+            icon: summary === null || summary === void 0 ? void 0 : summary.defaultIcon,
+            image: summary === null || summary === void 0 ? void 0 : summary.defaultImage
+        } }, componentProps), { onEdit: function (itemIndex) {
+            update(function (draft) {
+                draft.editableComponent = createEditableComponent(draft.components[itemIndex].getLocalValue());
+                draft.editableIndex = itemIndex;
+            });
+        }, onAdd: function () {
+            update(function (draft) {
+                draft.editableComponent = createEditableComponent(null);
+                draft.editableIndex = null;
+                draft.errors = [];
+            });
+        }, onSave: function () {
+            var _this = this;
+            var _a;
+            var isValid = (_a = this.editableComponent) === null || _a === void 0 ? void 0 : _a.validate();
+            if (!isValid) {
+                return false;
+            }
+            update(function (draft) {
+                if (draft.editableComponent === null) {
+                    return;
+                }
+                if (draft.editableIndex === null) {
+                    // Adding a new item
+                    var newComponent = __assign({}, draft.editableComponent);
+                    draft.components = __spreadArray(__spreadArray([], _this.components, true), [newComponent], false);
+                }
+                else {
+                    // Editing an item
+                    draft.components[draft.editableIndex] = __assign(__assign({}, draft.editableComponent), { uid: draft.components[draft.editableIndex].uid });
+                }
+                draft.editableComponent = null;
+                draft.editableIndex = null;
+            });
+            return true;
+        }, onRemove: function () {
+            update(function (draft) {
+                if (draft.editableIndex === null) {
+                    return;
+                }
+                draft.components.splice(draft.editableIndex, 1);
+                draft.editableComponent = null;
+                draft.editableIndex = null;
+            });
+        }, getChildren: function () {
+            return this.editableComponent !== null
+                ? __spreadArray(__spreadArray([], this.components, true), [this.editableComponent], false) : this.components;
+        }, getSubmittableValue: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, Promise.all(this.components.map(function (component) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, component.getSubmittableValue()];
+                        }); }); }))];
+                });
+            });
+        }, getSummary: function () {
+            // It doesn't make sense to pass a value here
+            return summariser(null);
+        }, getLocalValue: function () {
+            return this.components.map(function (component) { return component.getLocalValue(); });
+        }, validate: function () {
+            var messages = getValidationErrors(this.getLocalValue());
+            var childComponentsValid = validateComponents(this.getChildren());
+            update(function (draft) {
+                draft.errors = messages;
+            });
+            return messages.length === 0 && childComponentsValid;
+        } });
+};

package/build/revamp/domain/components/searchComponent/SearchComponent.js

@@ -0,0 +1,108 @@
+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 { getInputUpdateFunction } from '../utils/component-utils';
+import { debounce } from '../utils/debounce';
+var DEBOUNCE_TIME = 400;
+export var createSearchComponent = function (searchProps, performSearch, onAction, updateComponent) {
+    var uid = searchProps.uid, control = searchProps.control, emptyMessage = searchProps.emptyMessage, margin = searchProps.margin, title = searchProps.title;
+    var update = getInputUpdateFunction(uid, updateComponent);
+    var abortController = new AbortController();
+    var search = function (query, searchConfig) {
+        abortController.abort();
+        abortController = new AbortController();
+        var signal = abortController.signal;
+        performSearch({
+            signal: signal,
+            query: query,
+            config: searchConfig
+        })
+            .then(function (state) {
+            if (!signal.aborted) {
+                update(function (draft) {
+                    draft.results = state;
+                    draft.isLoading = false;
+                });
+            }
+        })["catch"](function () {
+            if (!signal.aborted) {
+                update(function (draft) {
+                    draft.error = 'No response';
+                    draft.isLoading = false;
+                });
+            }
+        });
+    };
+    var onSelect = function (_a) {
+        var type = _a.type, value = _a.value;
+        if (type === 'action') {
+            void onAction(value);
+        }
+        else {
+            update(function (draft) {
+                draft.query = value.query;
+            });
+            search(value.query, { method: value.method, param: value.param, url: value.url });
+        }
+    };
+    var debouncedSearch = debounce(search, DEBOUNCE_TIME);
+    var onChange = function (query) {
+        update(function (draft) {
+            draft.query = query;
+            draft.isLoading = true;
+        });
+        debouncedSearch(query);
+    };
+    return {
+        type: 'search',
+        uid: uid,
+        control: control,
+        emptyMessage: emptyMessage,
+        margin: margin,
+        title: title,
+        isLoading: false,
+        query: '',
+        results: [],
+        getSubmittableValue: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, null];
+        }); }); },
+        getLocalValue: function () { return null; },
+        getSummary: function () { return ({}); },
+        validate: function () { return true; },
+        onChange: onChange,
+        onSelect: onSelect
+    };
+};

package/build/revamp/domain/components/utils/component-utils.js

@@ -0,0 +1,18 @@
+/**
+ * Helper function to update a component.
+ *
+ * `updateComponent` is generic, meaning we have to specify the type of the draft whenever we use it. This function takes
+ * the component uid and type, and returns a typed function that will update the component without the need to type assert.
+ *
+ * @param uid uid of the component
+ * @param updateComponent the updateComponent function that will update the component with the given uid
+ * @returns a function that accepts a function that will update the component
+ */
+export var getInputUpdateFunction = function (uid, updateComponent) {
+    return function (updateFn) {
+        updateComponent(uid, function (draft) {
+            var draftState = draft;
+            updateFn(draftState);
+        });
+    };
+};

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

@@ -0,0 +1,38 @@
+export var debounce = function (callback, waitMs) {
+    var timeoutId;
+    var lastArgs;
+    var clearTimer = function () {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+        lastArgs = null;
+    };
+    var debouncedFn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        lastArgs = args;
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(function () {
+            callback.apply(void 0, lastArgs);
+            timeoutId = null;
+            lastArgs = null;
+        }, waitMs);
+    };
+    debouncedFn.cancel = function () {
+        if (timeoutId !== null) {
+            clearTimer();
+        }
+    };
+    debouncedFn.flush = function () {
+        if (timeoutId !== null) {
+            callback.apply(void 0, lastArgs);
+            clearTimer();
+        }
+    };
+    return debouncedFn;
+};

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

@@ -0,0 +1,46 @@
+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 };
+    }
+};
+export var toBase64 = function (file) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, new Promise(function (resolve, reject) {
+                var reader = new FileReader();
+                reader.addEventListener('load', function () { return resolve(reader.result); });
+                reader.addEventListener('error', reject);
+                reader.readAsDataURL(file);
+            })];
+    });
+}); };

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,40 @@
+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 { isArray, isNullish } from '../../../utils/type-validators';
+import { getComponentForLocalValueKey } from './getComponentForLocalValueKey';
+export var isPartialLocalValueMatch = function (partialValue, component) {
+    if (isArray(partialValue) && component.type === 'repeatable') {
+        var children_1 = component.getChildren();
+        return partialValue.every(function (value, index) {
+            var childComponent = children_1[index];
+            return childComponent ? isPartialLocalValueMatch(value, childComponent) : false;
+        });
+    }
+    var componentValue = component.getLocalValue();
+    if (isObjectLocalValue(partialValue) && isObjectLocalValue(componentValue)) {
+        var allKeys = Array.from(new Set(__spreadArray(__spreadArray([], Object.keys(partialValue), true), Object.keys(componentValue), true)));
+        var matchingKeys = allKeys.filter(function (key) { return !isNullish(partialValue[key]) && !isNullish(componentValue[key]); });
+        return matchingKeys.every(function (key) {
+            var componentForKey = getComponentForLocalValueKey(key, component);
+            return componentForKey ? isPartialLocalValueMatch(partialValue[key], componentForKey) : false;
+        });
+    }
+    if (partialValue instanceof File && componentValue instanceof File) {
+        return areEquivalentFiles(partialValue, componentValue);
+    }
+    if ('isPersisted' in component && component.isPersisted) {
+        return true;
+    }
+    return partialValue === componentValue;
+};
+var areEquivalentFiles = function (fileA, fileB) {
+    return fileA.name === fileB.name && fileA.type === fileB.type && fileA.size === fileB.size;
+};

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

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

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

@@ -0,0 +1,133 @@
+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';
+/**
+ * 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 (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];
+        });
+    }); };
+};