@wise/dynamic-flow-client 5.13.2-experimental-e750b58 → 5.13.2

package/build/domain/components/MoneyInputComponent.js

@@ -0,0 +1,57 @@
+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;
+};
+import { getLocalValueValidator } from '../features/validation/validation-functions';
+import { getInputUpdateFunction } from './utils/component-utils';
+export const createMoneyInputComponent = (moneyInputProps, onComponentUpdate) => {
+    const { id, uid, schemaId, analyticsId, amountKey, amountComponent, currencyKey, currencyComponent, control, description, help, hidden, media, summariser, title, tags, extraValues, checks } = moneyInputProps, rest = __rest(moneyInputProps, ["id", "uid", "schemaId", "analyticsId", "amountKey", "amountComponent", "currencyKey", "currencyComponent", "control", "description", "help", "hidden", "media", "summariser", "title", "tags", "extraValues", "checks"]);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const moneyComponent = Object.assign({ type: 'money-input', kind: 'input', id,
+        uid,
+        schemaId,
+        analyticsId, autoComplete: 'off', control,
+        description,
+        help,
+        hidden,
+        media,
+        title,
+        tags, value: {
+            [amountKey]: amountComponent.getLocalValue(),
+            [currencyKey]: currencyComponent.getLocalValue(),
+        }, _update(updateFn) {
+            update(this, updateFn);
+        }, components: {
+            amount: amountComponent,
+            currency: currencyComponent,
+        }, async getSubmittableValue() {
+            return Object.assign({ [amountKey]: await amountComponent.getSubmittableValue(), [currencyKey]: await currencyComponent.getSubmittableValue() }, extraValues);
+        },
+        getSubmittableValueSync() {
+            return Object.assign({ [amountKey]: amountComponent.getSubmittableValueSync(), [currencyKey]: currencyComponent.getSubmittableValueSync() }, extraValues);
+        },
+        getLocalValue() {
+            return Object.assign({ [amountKey]: amountComponent.getLocalValue(), [currencyKey]: currencyComponent.getLocalValue() }, extraValues);
+        },
+        getSummary() {
+            return summariser(this.getLocalValue());
+        },
+        validate() {
+            const errors = getValidationErrors(amountComponent.getLocalValue());
+            this._update((draft) => {
+                draft.errors = errors;
+            });
+            return amountComponent.validate() && currencyComponent.validate() && errors.length === 0;
+        },
+        onBlur() { }, // noop
+        onFocus() { } }, rest);
+    return moneyComponent;
+};

package/build/domain/components/MultiSelectInputComponent.js

@@ -0,0 +1,81 @@
+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;
+};
+import { isArray } from '../../utils/type-validators';
+import { getLocalValueValidator } from '../features/validation/validation-functions';
+import { getComponentValidationAsync } from '../features/validationAsync/getComponentValidationAsync';
+import { getInputUpdateFunction } from './utils/component-utils';
+export const createMultiSelectComponent = (multiSelectProps, onComponentUpdate) => {
+    const { uid, checks, options, initialValue, performValidationAsync, schemaOnChange, onValueChange } = multiSelectProps, rest = __rest(multiSelectProps, ["uid", "checks", "options", "initialValue", "performValidationAsync", "schemaOnChange", "onValueChange"]);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const children = options.map((option) => option.component);
+    const selectedIndices = getInitialModelIndices(initialValue, children);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const validateAsync = performValidationAsync
+        ? getComponentValidationAsync(update, performValidationAsync)
+        : undefined;
+    const component = Object.assign(Object.assign({ uid, type: 'multi-select', kind: 'input', children,
+        options,
+        selectedIndices, value: null }, rest), { _update(updateFn) {
+            update(this, updateFn);
+        },
+        onSelect(indices) {
+            this._update((draft) => {
+                draft.selectedIndices = indices;
+                draft.errors = [];
+            });
+            void (schemaOnChange === null || schemaOnChange === void 0 ? void 0 : schemaOnChange());
+            const errors = getValidationErrors(this.getLocalValue());
+            this._update((draft) => {
+                draft.errors = errors;
+            });
+            if (this.validate()) {
+                validateAsync === null || validateAsync === void 0 ? void 0 : validateAsync(this, this.getLocalValue()).catch(() => { }); // Noop
+            }
+            onValueChange();
+        },
+        onBlur() { }, // Noop
+        onFocus() { }, // Noop
+        getLocalValue() {
+            var _a, _b;
+            return (_b = (_a = this.getSelectedChildren()) === null || _a === void 0 ? void 0 : _a.map((child) => child.getLocalValue())) !== null && _b !== void 0 ? _b : null;
+        },
+        validate() {
+            const errors = getValidationErrors(this.getLocalValue());
+            this._update((draft) => {
+                draft.errors = errors;
+            });
+            return errors.length === 0;
+        },
+        async getSubmittableValue() {
+            const selected = this.getSelectedChildren();
+            if (selected) {
+                return Promise.all(selected.map(async (child) => child.getSubmittableValue()));
+            }
+            return null;
+        },
+        getSubmittableValueSync() {
+            var _a, _b;
+            return (_b = (_a = this.getSelectedChildren()) === null || _a === void 0 ? void 0 : _a.map((child) => child.getSubmittableValueSync())) !== null && _b !== void 0 ? _b : null;
+        }, getSummary: () => ({}), getChildren() {
+            return this.children;
+        },
+        getSelectedChildren() {
+            return this.selectedIndices.map((i) => this.children[i]);
+        } });
+    return component;
+};
+const getInitialModelIndices = (model, options) => {
+    if (!isArray(model)) {
+        return [];
+    }
+    return model.map((m) => options.findIndex((o) => o.getLocalValue() === m)).filter((n) => n >= 0);
+};

package/build/domain/components/MultiUploadInputComponent.js

@@ -0,0 +1,88 @@
+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;
+};
+import { getComponentMultiPersistAsync } from '../features/persistAsync/getComponentMultiPersistAsync';
+import { getLocalValueValidator } from '../features/validation/validation-functions';
+import { getInputUpdateFunction } from './utils/component-utils';
+import { toBase64 } from './utils/file-utils';
+import { getRandomId } from './utils/getRandomId';
+export const createMultiUploadInputComponent = (uploadInputProps, onComponentUpdate) => {
+    const { uid, id, checks, fileChecks, format, performPersistAsync, onValueChange, summariser } = uploadInputProps, rest = __rest(uploadInputProps, ["uid", "id", "checks", "fileChecks", "format", "performPersistAsync", "onValueChange", "summariser"]);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const getFileValidationErrors = getLocalValueValidator(fileChecks);
+    const persist = performPersistAsync
+        ? getComponentMultiPersistAsync(update, performPersistAsync)
+        : undefined;
+    const uploadComponent = Object.assign({ type: 'multi-upload', kind: 'input', uid,
+        id,
+        format, files: [], _update(updateFn) {
+            update(this, updateFn);
+        },
+        onBlur() {
+            this.validate();
+        },
+        onFocus() { }, // Noop
+        async onRemoveFile(index) {
+            var _a;
+            this._update((draft) => {
+                draft.value.splice(index, 1);
+                draft.files.splice(index, 1);
+            });
+            if (persist) {
+                (_a = this.persistedState[index]) === null || _a === void 0 ? void 0 : _a.abortController.abort();
+                this._update((draft) => {
+                    draft.persistedState.splice(index, 1);
+                });
+            }
+        },
+        async onInsertFile(index, file) {
+            const fileErrors = getFileValidationErrors(file);
+            const fileId = getRandomId();
+            const base64Value = format === 'base64' ? await toBase64(file) : null;
+            this._update((draft) => {
+                draft.value.splice(index, 0, file);
+                draft.files.splice(index, 0, { file, id: fileId, errors: fileErrors, base64Value });
+                draft.errors = [];
+            });
+            if (persist) {
+                await persist(this, index, format === 'blob' ? file : base64Value);
+            }
+            onValueChange();
+            return fileId;
+        },
+        async getSubmittableValue() {
+            if (persist) {
+                return Promise.all(this.persistedState.map(async ({ submission }) => submission));
+            }
+            return this.files.map(({ base64Value }) => base64Value);
+        },
+        getSubmittableValueSync() {
+            if (persist) {
+                return this.persistedState.map(({ lastResponse }) => lastResponse);
+            }
+            return this.files.map(({ base64Value }) => base64Value);
+        },
+        getSummary() {
+            return summariser(this.getLocalValue().map(({ name }) => name));
+        },
+        getLocalValue() {
+            return this.value;
+        },
+        validate() {
+            const errorMsgs = getValidationErrors(this.getLocalValue());
+            this._update((draft) => {
+                draft.errors = errorMsgs;
+            });
+            return errorMsgs.length === 0 && this.files.every(({ errors }) => errors.length === 0);
+        } }, rest);
+    return uploadComponent;
+};

package/build/domain/components/NumberInputComponent.js

@@ -0,0 +1,73 @@
+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;
+};
+import { getDebouncedSchemaOnChange } from '../features/schema-on-change/getDebouncedSchemaOnChange';
+import { getLocalValueValidator } from '../features/validation/validation-functions';
+import { getDebouncedComponentValidationAsync } from '../features/validationAsync/getComponentValidationAsync';
+import { getInputUpdateFunction } from './utils/component-utils';
+export const createNumberInputComponent = (numberInputProps, onComponentUpdate) => {
+    const { uid, id, checks, schemaOnChange, performValidationAsync, onValueChange, onPersistAsync, summariser } = numberInputProps, rest = __rest(numberInputProps, ["uid", "id", "checks", "schemaOnChange", "performValidationAsync", "onValueChange", "onPersistAsync", "summariser"]);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const performOnChange = getDebouncedSchemaOnChange(schemaOnChange, getValidationErrors);
+    const validateAsync = performValidationAsync
+        ? getDebouncedComponentValidationAsync(update, performValidationAsync)
+        : undefined;
+    const numberComponent = Object.assign({ type: 'number', kind: 'input', uid,
+        id,
+        _update(updateFn) {
+            update(this, updateFn);
+        },
+        onBlur() {
+            const isValid = this.validate();
+            performOnChange === null || performOnChange === void 0 ? void 0 : performOnChange.flush();
+            if (isValid) {
+                void (onPersistAsync === null || onPersistAsync === void 0 ? void 0 : onPersistAsync().catch(() => { }));
+                validateAsync === null || validateAsync === void 0 ? void 0 : validateAsync.flush();
+            }
+        },
+        onFocus() { }, // Noop
+        onChange(updatedValue) {
+            const prevValue = this.value;
+            this._update((draft) => {
+                draft.errors = [];
+                draft.validationAsyncState.messages = {};
+                draft.value = updatedValue;
+            });
+            performOnChange === null || performOnChange === void 0 ? void 0 : performOnChange(prevValue, updatedValue);
+            const isValid = getValidationErrors(updatedValue).length === 0;
+            if (isValid) {
+                validateAsync === null || validateAsync === void 0 ? void 0 : validateAsync(this, updatedValue);
+            }
+            onValueChange();
+        },
+        async getSubmittableValue() {
+            return this.getSubmittableValueSync();
+        },
+        getSubmittableValueSync() {
+            var _a;
+            return (_a = this.getLocalValue()) !== null && _a !== void 0 ? _a : null;
+        },
+        getSummary() {
+            return summariser(this.getLocalValue());
+        },
+        getLocalValue() {
+            return this.value;
+        },
+        validate() {
+            const errors = getValidationErrors(this.getLocalValue());
+            this._update((draft) => {
+                draft.errors = errors;
+            });
+            return errors.length === 0;
+        } }, rest);
+    return numberComponent;
+};

package/build/domain/components/ObjectComponent.js

@@ -0,0 +1,45 @@
+import { mergeSummaries, summariseFromChildren } from '../features/summary/summary-utils';
+import { validateComponents } from '../features/validation/validation-functions';
+export const createObjectComponent = (objectProps) => {
+    const { uid, schemaId, analyticsId, alert, componentMap, control, description, displayOrder, help, hidden, media, summariser, title, tags, } = objectProps;
+    return {
+        type: 'object',
+        kind: 'input',
+        uid,
+        schemaId,
+        analyticsId,
+        alert,
+        componentMap,
+        control,
+        description,
+        help,
+        hidden,
+        media,
+        title,
+        tags,
+        getChildren() {
+            return displayOrder.map((propName) => this.componentMap[propName]);
+        },
+        async getSubmittableValue() {
+            return Promise.all(displayOrder.map(async (propName) => this.componentMap[propName].getSubmittableValue().then((value) => ({ value, propName })))).then((values) => values.reduce((acc, { value, propName }) => (Object.assign(Object.assign({}, acc), (value === null ? {} : { [propName]: value }))), {}));
+        },
+        getSubmittableValueSync() {
+            return mergeChildrenValues(displayOrder, (propName) => this.componentMap[propName].getSubmittableValueSync());
+        },
+        getSummary() {
+            const summary = summariser(this.getLocalValue());
+            const childSummary = summariseFromChildren(this.getChildren());
+            return mergeSummaries(summary, childSummary);
+        },
+        getLocalValue() {
+            return mergeChildrenValues(displayOrder, (propName) => this.componentMap[propName].getLocalValue());
+        },
+        validate() {
+            return hidden ? true : validateComponents(this.getChildren());
+        },
+    };
+};
+const mergeChildrenValues = (displayOrder, getComponentValue) => displayOrder.reduce((acc, propName) => {
+    const componentValue = getComponentValue(propName);
+    return Object.assign(Object.assign({}, acc), (componentValue === null ? {} : { [propName]: componentValue }));
+}, {});

package/build/domain/components/ParagraphComponent.js

@@ -0,0 +1 @@
+export const createParagraphComponent = (paragraphProps) => (Object.assign({ type: 'paragraph', kind: 'layout' }, paragraphProps));

package/build/domain/components/PersistAsyncComponent.js

@@ -0,0 +1,92 @@
+import { abortAndResetController } from '../features/utils/http-utils';
+import { getInputUpdateFunction } from './utils/component-utils';
+import { isExactLocalValueMatch } from './utils/isExactLocalValueMatch';
+export const createPersistAsyncComponent = (props, performPersistAsync, schemaOnChange, onComponentUpdate) => {
+    const { uid, analyticsId, schemaId, component, hidden, model, localValue, tags } = props;
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const paComponent = {
+        type: 'persist-async',
+        kind: 'input',
+        uid,
+        analyticsId,
+        schemaId,
+        component,
+        hidden,
+        lastSubmitted: model != null ? (localValue !== null && localValue !== void 0 ? localValue : null) : null,
+        lastResponse: model !== null && model !== void 0 ? model : null,
+        submission: Promise.resolve(model !== null && model !== void 0 ? model : null),
+        abortController: new AbortController(),
+        errors: [],
+        tags,
+        _update(updateFn) {
+            update(this, updateFn);
+        },
+        validate() {
+            return this.component.validate();
+        },
+        getLocalValue() {
+            return this.component.getLocalValue();
+        },
+        async getSubmittableValue() {
+            return this.persist();
+        },
+        getSubmittableValueSync() {
+            return this.lastResponse;
+        },
+        getSummary() {
+            return this.component.getSummary();
+        },
+        async persist() {
+            const childLocalValue = this.component.getLocalValue();
+            if (isExactLocalValueMatch(childLocalValue, this.lastSubmitted)) {
+                return this.submission;
+            }
+            const newAbortController = abortAndResetController(this.abortController);
+            if (childLocalValue == null || childLocalValue === '') {
+                const resolvedNull = Promise.resolve(null);
+                this._update((draft) => {
+                    draft.abortController = newAbortController;
+                    draft.lastResponse = null;
+                    draft.lastSubmitted = childLocalValue;
+                    draft.submission = resolvedNull;
+                    draft.errors = [];
+                });
+                void (schemaOnChange === null || schemaOnChange === void 0 ? void 0 : schemaOnChange());
+                return resolvedNull;
+            }
+            const { signal } = newAbortController;
+            const newSubmission = performPersistAsync({ value: childLocalValue, signal })
+                .then((token) => {
+                this._update((draft) => {
+                    draft.lastResponse = token;
+                    draft.errors = [];
+                });
+                void (schemaOnChange === null || schemaOnChange === void 0 ? void 0 : schemaOnChange());
+                return token;
+            })
+                .catch((error) => {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    return null;
+                }
+                this._update((draft) => {
+                    draft.lastResponse = null;
+                    draft.lastSubmitted = null;
+                    draft.submission = Promise.resolve(null);
+                    if (this.component.type !== 'upload') {
+                        draft.errors = error instanceof Error ? [error.message] : [];
+                    }
+                });
+                throw error;
+            });
+            this._update((draft) => {
+                draft.abortController = newAbortController;
+                draft.lastSubmitted = childLocalValue;
+                draft.lastResponse = null;
+                draft.submission = newSubmission;
+                draft.errors = [];
+            });
+            return newSubmission;
+        },
+    };
+    return paComponent;
+};

package/build/domain/components/ProgressComponent.js

@@ -0,0 +1 @@
+export const createProgressComponent = (progressProps) => (Object.assign({ type: 'progress', kind: 'layout' }, progressProps));

package/build/domain/components/RepeatableComponent.js

@@ -0,0 +1,103 @@
+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;
+};
+import { getLocalValueValidator, validateComponents, } from '../features/validation/validation-functions';
+import { getInputUpdateFunction } from './utils/component-utils';
+export const createRepeatableComponent = (repeatableProps, onComponentUpdate) => {
+    const { uid, schemaId, analyticsId, checks, components, summary, onValueChange, createEditableComponent, summariser } = repeatableProps, componentProps = __rest(repeatableProps, ["uid", "schemaId", "analyticsId", "checks", "components", "summary", "onValueChange", "createEditableComponent", "summariser"]);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const repeatableComponent = Object.assign(Object.assign({ uid,
+        schemaId,
+        analyticsId, type: 'repeatable', kind: 'input', 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,
+            media: summary === null || summary === void 0 ? void 0 : summary.defaultMedia,
+        } }, componentProps), { _update(updateFn) {
+            update(this, updateFn);
+        },
+        onEdit(itemIndex) {
+            this._update((draft) => {
+                draft.editableComponent = createEditableComponent(draft.components[itemIndex].getLocalValue());
+                draft.editableIndex = itemIndex;
+            });
+        },
+        onAdd() {
+            this._update((draft) => {
+                draft.editableComponent = createEditableComponent(null);
+                draft.editableIndex = null;
+                draft.errors = [];
+            });
+        },
+        onSave() {
+            var _a;
+            const isValid = (_a = this.editableComponent) === null || _a === void 0 ? void 0 : _a.validate();
+            if (!isValid) {
+                return false;
+            }
+            this._update((draft) => {
+                if (draft.editableComponent === null) {
+                    return;
+                }
+                if (draft.editableIndex === null) {
+                    // Adding a new item
+                    const newComponent = Object.assign({}, draft.editableComponent);
+                    draft.components = [...this.components, newComponent];
+                }
+                else {
+                    // Editing an item
+                    draft.components[draft.editableIndex] = Object.assign(Object.assign({}, draft.editableComponent), { uid: draft.components[draft.editableIndex].uid });
+                }
+                draft.editableComponent = null;
+                draft.editableIndex = null;
+            });
+            onValueChange();
+            return true;
+        },
+        onRemove() {
+            this._update((draft) => {
+                if (draft.editableIndex === null) {
+                    return;
+                }
+                draft.components.splice(draft.editableIndex, 1);
+                draft.editableComponent = null;
+                draft.editableIndex = null;
+            });
+            onValueChange();
+        },
+        getChildren() {
+            return this.editableComponent !== null
+                ? [...this.components, this.editableComponent]
+                : this.components;
+        },
+        async getSubmittableValue() {
+            return Promise.all(this.components.map(async (component) => component.getSubmittableValue()));
+        },
+        getSubmittableValueSync() {
+            return this.components.map((component) => component.getSubmittableValueSync());
+        },
+        getSummary() {
+            // It doesn't make sense to pass a value here
+            return summariser(null);
+        },
+        getLocalValue() {
+            return this.components.map((component) => component.getLocalValue());
+        },
+        validate() {
+            const messages = getValidationErrors(this.getLocalValue());
+            const childComponentsValid = validateComponents(this.getChildren());
+            this._update((draft) => {
+                draft.errors = messages;
+            });
+            return messages.length === 0 && childComponentsValid;
+        } });
+    return repeatableComponent;
+};

package/build/domain/components/ReviewComponent.js

@@ -0,0 +1 @@
+export const createReviewComponent = (reviewProps) => (Object.assign({ type: 'review', kind: 'layout' }, reviewProps));