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

package/build/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/repeatableSchema/RepeatableSchemaStep.js

@@ -0,0 +1,85 @@
+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 __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 { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { useIntl } from 'react-intl';
+import { DynamicFlowStep } from '../../../../dynamicFlow/DynamicFlowStep';
+import messages from '../../../../../common/messages/repeatable.messages';
+function RepeatableSchemaStep(_a) {
+    var type = _a.type, schema = _a.schema, model = _a.model, errors = _a.errors, submitted = _a.submitted, onModelChange = _a.onModelChange, onAction = _a.onAction;
+    var formatMessage = useIntl().formatMessage;
+    var _b = useState(undefined), filename = _b[0], setFilename = _b[1];
+    var step = {
+        layout: __spreadArray([
+            {
+                type: 'form',
+                schema: schema.items
+            },
+            {
+                type: 'button',
+                control: 'primary',
+                action: {
+                    url: type,
+                    title: formatMessage(type === 'add' ? messages.addItem : messages.editItem)
+                }
+            }
+        ], (type === 'edit'
+            ? [
+                {
+                    type: 'button',
+                    context: 'negative',
+                    action: {
+                        url: 'remove',
+                        title: formatMessage(messages.removeItem)
+                    }
+                },
+            ]
+            : []), true),
+        title: '',
+        actions: [],
+        schemas: []
+    };
+    var onChange = function (props) {
+        var metadata = props.metadata, model = props.model, modelChangeProps = __rest(props, ["metadata", "model"]);
+        if (schema.items.format === 'base64url' &&
+            typeof model === 'string' &&
+            typeof (metadata === null || metadata === void 0 ? void 0 : metadata.filename) === 'string') {
+            setFilename(metadata.filename);
+        }
+        onModelChange(__assign(__assign({}, modelChangeProps), { model: model }));
+    };
+    return (_jsx(DynamicFlowStep, { step: step, model: model, stepLayoutOptions: { displayStepTitle: false }, submitted: submitted, formErrors: errors, globalError: null, onAction: function (action) {
+            onAction(action.url, filename);
+            setFilename(undefined);
+        }, onModelChange: onChange }));
+}
+export default RepeatableSchemaStep;

package/build/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/repeatableSchema/utils/summary-utils.js

@@ -0,0 +1,135 @@
+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);
+};
+import { getSchemaType, isConstSchema, isNullableStringModel, isObjectModel, isOneOfObjectSchema, } from '../../../../../common/utils';
+import { isString } from '../../../../../common/validators';
+import { getActiveSchemaIndex, getBestMatchingSchemaIndexForValue, } from '../../../../oneOfSchema/utils';
+export var getItemSummaryFromSchema = function (schema, model, defaults, summaryTextOverride) {
+    if (defaults === void 0) { defaults = {}; }
+    var _a = defaults.defaultTitle, defaultTitle = _a === void 0 ? '' : _a, _b = defaults.defaultDescription, defaultDescription = _b === void 0 ? '' : _b, defaultIcon = defaults.defaultIcon, defaultImage = defaults.defaultImage;
+    var title = getSummaryPropFromSchema({
+        schema: schema,
+        model: model,
+        providesProp: 'providesTitle',
+        getValueFromSchema: function (schema, model) {
+            return summaryTextOverride !== null && summaryTextOverride !== void 0 ? summaryTextOverride : getStringValueFromSchema(schema, model);
+        }
+    });
+    var description = getSummaryPropFromSchema({
+        schema: schema,
+        model: model,
+        providesProp: 'providesDescription',
+        getValueFromSchema: function (schema, model) {
+            return summaryTextOverride !== null && summaryTextOverride !== void 0 ? summaryTextOverride : getStringValueFromSchema(schema, model);
+        }
+    });
+    var icon = getSummaryPropFromSchema({
+        schema: schema,
+        model: model,
+        providesProp: 'providesIcon',
+        getValueFromSchema: function (schema) { var _a; return (_a = schema.icon) !== null && _a !== void 0 ? _a : null; }
+    });
+    var image = getSummaryPropFromSchema({
+        schema: schema,
+        model: model,
+        providesProp: 'providesImage',
+        getValueFromSchema: function (schema) { var _a; return (_a = schema.image) !== null && _a !== void 0 ? _a : null; }
+    });
+    return {
+        value: model,
+        title: title || defaultTitle,
+        description: description || defaultDescription,
+        icon: icon || defaultIcon,
+        image: image || defaultImage
+    };
+};
+var getSummaryPropFromSchema = function (props) {
+    var schema = props.schema, model = props.model, providesProp = props.providesProp, getValueFromSchema = props.getValueFromSchema;
+    var type = getSchemaType(schema);
+    if (schemaSummaryProvides(schema.summary, providesProp)) {
+        return getValueFromSchema(schema, model);
+    }
+    switch (type) {
+        case 'object': {
+            return getObjectValueFromSchema(props);
+        }
+        case 'oneOf': {
+            return getOneOfValueFromSchema(props);
+        }
+        case 'allOf': {
+            return getAllOfValueFromSchema(props);
+        }
+        default:
+            return null;
+    }
+};
+var getObjectValueFromSchema = function (props) {
+    var schema = props.schema, model = props.model;
+    var objectSchema = schema;
+    // eslint-disable-next-line guard-for-in, no-restricted-syntax
+    for (var propertyKey in objectSchema.properties) {
+        var propertySchema = objectSchema.properties[propertyKey];
+        var propertyModel = isObjectModel(model) && propertyKey in model ? model[propertyKey] : null;
+        var result = getSummaryPropFromSchema(__assign(__assign({}, props), { schema: propertySchema, model: propertyModel }));
+        if (result) {
+            return result;
+        }
+    }
+    return null;
+};
+var getOneOfValueFromSchema = function (props) {
+    var schema = props.schema, model = props.model;
+    if (isOneOfObjectSchema(schema)) {
+        if (!isObjectModel(model)) {
+            return null;
+        }
+        var activeSchemaIndex_1 = getBestMatchingSchemaIndexForValue(schema, model);
+        if (activeSchemaIndex_1 === null || activeSchemaIndex_1 < 0) {
+            return null;
+        }
+        var activeSchema = schema.oneOf[activeSchemaIndex_1];
+        return getSummaryPropFromSchema(__assign(__assign({}, props), { schema: activeSchema }));
+    }
+    var oneOfSchema = schema;
+    var activeSchemaIndex = getActiveSchemaIndex(oneOfSchema, model);
+    if (activeSchemaIndex === null || activeSchemaIndex < 0) {
+        return null;
+    }
+    return getSummaryPropFromSchema(__assign(__assign({}, props), { schema: oneOfSchema.oneOf[activeSchemaIndex] }));
+};
+var getAllOfValueFromSchema = function (props) {
+    var schema = props.schema;
+    var allOfSchema = schema;
+    for (var _i = 0, _a = allOfSchema.allOf; _i < _a.length; _i++) {
+        var childSchema = _a[_i];
+        var result = getSummaryPropFromSchema(__assign(__assign({}, props), { schema: childSchema }));
+        if (result) {
+            return result;
+        }
+    }
+    return null;
+};
+var getStringValueFromSchema = function (schema, model) {
+    if (isConstSchema(schema)) {
+        if (schema.title) {
+            return schema.title;
+        }
+        if (isString(schema["const"])) {
+            return schema["const"];
+        }
+        return null;
+    }
+    return isNullableStringModel(model) ? model : null;
+};
+var schemaSummaryProvides = function (summary, providesProp) {
+    // eslint-disable-next-line prefer-object-has-own, no-implicit-coercion
+    return !!summary && Object.hasOwnProperty.call(summary, providesProp) && Boolean(summary[providesProp]);
+};

package/build/legacy/jsonSchemaForm/arrayTypeSchema/index.js

@@ -0,0 +1 @@
+export { default } from './ArraySchema';

package/build/legacy/jsonSchemaForm/basicTypeSchema/BasicTypeSchema.js

@@ -0,0 +1,111 @@
+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);
+};
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import classNames from 'classnames';
+import { useEffect, useMemo, useState } from 'react';
+import { generateRandomId } from '../../common/utils';
+import { getValidBasicModelOrNull, getValidationFailures, isNull, isUndefined, } from '../../common/validators';
+import { DynamicAlert } from '../../layout';
+import ControlFeedback from '../controlFeedback';
+import Help from '../help';
+import SchemaFormControl from '../schemaFormControl';
+var isNullish = function (value) {
+    return isNull(value) || isUndefined(value);
+};
+var getDefaultValue = function (schema) {
+    return schema.type === 'boolean' && isNullish(schema["default"]) ? false : schema["default"];
+};
+var BasicTypeSchema = function (props) {
+    var _a, _b, _c;
+    var onChange = function (newModel, _type, metadata) {
+        setChanged(true);
+        setModelAndBroadcast(sanitiseModel(newModel), 'user', metadata);
+    };
+    var getValidationKeys = function (newModel) {
+        return getValidationFailures(newModel, props.schema, props.required);
+    }; // TODO: LOW avoid type assertion
+    var setModelAndBroadcast = function (newModel, type, metadata) {
+        setModel(newModel);
+        var validationKeys = getValidationKeys(newModel);
+        setValidations(validationKeys);
+        var broadcastModel = newModel;
+        setLastModel(broadcastModel);
+        if (broadcastModel !== lastModel) {
+            props.onChange({
+                model: broadcastModel,
+                triggerSchema: props.schema,
+                triggerModel: broadcastModel,
+                lastTriggerModel: lastModel,
+                type: type,
+                metadata: metadata
+            });
+        }
+    };
+    var sanitiseModel = function (newModel) {
+        return getValidBasicModelOrNull(newModel, props.schema);
+    };
+    var onFocus = function () { return setFocused(true); };
+    var onBlur = function () {
+        setFocused(false);
+        setBlurred(true);
+        if (props.onBlur) {
+            props.onBlur();
+        }
+    };
+    var _d = useState((_a = props.model) !== null && _a !== void 0 ? _a : null), model = _d[0], setModel = _d[1];
+    var _e = useState((_b = props.model) !== null && _b !== void 0 ? _b : null), lastModel = _e[0], setLastModel = _e[1];
+    var _f = useState(false), changed = _f[0], setChanged = _f[1];
+    var _g = useState(false), focused = _g[0], setFocused = _g[1];
+    var _h = useState(false), blurred = _h[0], setBlurred = _h[1];
+    var _j = useState([]), validations = _j[0], setValidations = _j[1];
+    var id = useMemo(function () { return props.schema.$id || generateRandomId(); }, [props.schema.$id]);
+    var onSchemaChange = function () {
+        var defaultValue = getDefaultValue(props.schema);
+        // if no model, change to the default, only run this when the schema changes
+        if (isNullish(model) && !isNullish(defaultValue)) {
+            setModelAndBroadcast(defaultValue, 'init');
+        }
+        if (props.schema["const"]) {
+            setModelAndBroadcast(props.schema["const"], 'init');
+        }
+    };
+    var refreshValidations = function () {
+        setValidations(getValidationKeys(model));
+    };
+    var isConst = props.schema["const"];
+    var isHidden = props.schema.hidden || isConst;
+    useEffect(refreshValidations, [props.model, props.submitted]);
+    useEffect(onSchemaChange, [props.schema]);
+    useEffect(function () {
+        var _a;
+        var newModel = (_a = props.model) !== null && _a !== void 0 ? _a : null;
+        if (newModel !== model) {
+            setModel(newModel);
+        }
+    }, [props.model]);
+    var formGroupClasses = {
+        'form-group': true,
+        'has-error': ((props.submitted || !changed) && !!props.errors) ||
+            ((props.submitted || (changed && blurred)) && !!validations.length),
+        'has-info': !!props.schema.description || !!props.infoMessage
+    };
+    var showLabel = props.schema.format !== 'file' && props.schema.type !== 'boolean';
+    var schemaHelp = props.schema.help;
+    var feedbackId = "".concat(id, "-feedback");
+    return !isHidden ? (_jsxs(_Fragment, { children: [props.schema.alert && _jsx(DynamicAlert, { component: props.schema.alert }), _jsxs("div", __assign({ className: classNames(formGroupClasses) }, { children: [showLabel && (_jsxs("div", __assign({ className: "d-inline-block m-b-1" }, { children: [_jsx("label", __assign({ className: "control-label d-inline", htmlFor: id }, { children: props.schema.title })), !!schemaHelp && _jsx(Help, { help: schemaHelp })] }))), !showLabel && !!schemaHelp && _jsx(Help, { help: schemaHelp }), _jsx(SchemaFormControl, { id: id, schema: props.schema, value: model, disabled: !!props.disabled, onChange: onChange, onFocus: onFocus, onBlur: onBlur, describedBy: feedbackId }), _jsx(ControlFeedback, { id: feedbackId, changed: changed, focused: focused, blurred: blurred, submitted: props.submitted, errors: (_c = props.errors) !== null && _c !== void 0 ? _c : null, schema: props.schema, validations: validations, infoMessage: props.infoMessage })] }))] })) : null;
+};
+BasicTypeSchema.defaultProps = {
+    required: false,
+    disabled: false,
+    onBlur: null
+};
+export default BasicTypeSchema;

package/build/legacy/jsonSchemaForm/basicTypeSchema/index.js

@@ -0,0 +1 @@
+export { default } from './BasicTypeSchema';

package/build/legacy/jsonSchemaForm/controlFeedback/ControlFeedback.js

@@ -0,0 +1,86 @@
+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);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { InlineAlert } from '@transferwise/components';
+import { formatDate } from '@transferwise/formatting';
+import { useIntl } from 'react-intl';
+import validationArrayMessages from '../../../common/messages/validation.array.messages';
+import controlFeedbackMessages from '../../../common/messages/validation.messages';
+function ControlFeedback(props) {
+    var _a;
+    var defaultValidationMessages = useDefaultValidationMessages(props.schema);
+    var validationMessages = __assign(__assign(__assign({}, defaultValidationMessages), props.validationMessages), props.schema.validationMessages);
+    var isErrorVisible = (props.submitted || !props.changed) && Boolean(props.errors);
+    var isValidationVisible = !isErrorVisible &&
+        (props.submitted || (props.changed && props.blurred)) &&
+        Boolean((_a = props.validations) === null || _a === void 0 ? void 0 : _a.length);
+    var isDescriptionVisible = props.schema.description && !isErrorVisible && !isValidationVisible;
+    var hasInfoMessage = Boolean(props.infoMessage);
+    return (_jsxs("div", __assign({ id: props.id }, { children: [isErrorVisible ? _jsx(InlineAlert, __assign({ type: "error" }, { children: props.errors })) : null, isValidationVisible ? (_jsx(InlineAlert, __assign({ type: "error" }, { children: props.validations.map(function (validation) { return (_jsx("div", { children: validationMessages[validation] }, validation)); }) }))) : null, (isDescriptionVisible || hasInfoMessage) && (_jsxs(InlineAlert, __assign({ type: "info" }, { children: [isDescriptionVisible && _jsx("div", { children: props.schema.description }), hasInfoMessage && _jsx("div", { children: props.infoMessage })] })))] })));
+}
+ControlFeedback.defaultProps = {
+    errors: '',
+    validations: [],
+    validationMessages: {},
+    validationAsyncSuccessMessage: null
+};
+// TODO: avoid typre assertions in this function
+function useDefaultValidationMessages(schema) {
+    var _a = useIntl(), formatMessage = _a.formatMessage, locale = _a.locale;
+    var formattedMessages = {
+        type: formatMessage(controlFeedbackMessages.type),
+        minimum: formatMessage(controlFeedbackMessages.minimum, {
+            minimum: schema.minimum
+        }),
+        maximum: formatMessage(controlFeedbackMessages.maximum, {
+            maximum: schema.maximum
+        }),
+        minLength: formatMessage(controlFeedbackMessages.minLength, {
+            minLength: schema.minLength
+        }),
+        maxLength: formatMessage(controlFeedbackMessages.maxLength, {
+            maxLength: schema.maxLength
+        }),
+        minItems: formatMessage(validationArrayMessages.minItemsError, {
+            minItems: schema.minItems
+        }),
+        maxItems: formatMessage(validationArrayMessages.maxItemsError, {
+            maxItems: schema.maxItems
+        }),
+        pattern: formatMessage(controlFeedbackMessages.pattern),
+        required: formatMessage(controlFeedbackMessages.required)
+    };
+    if (schema.format === 'date') {
+        var dateOverrides = {
+            pattern: formatMessage(controlFeedbackMessages.patternDate),
+            minimum: schema.minimum
+                ? formatMessage(controlFeedbackMessages.minimumDate, {
+                    minimum: formatDate(new Date(schema.minimum), locale, {
+                        timeZone: 'UTC',
+                        dateStyle: 'long'
+                    })
+                })
+                : undefined,
+            maximum: schema.maximum
+                ? formatMessage(controlFeedbackMessages.maximumDate, {
+                    maximum: formatDate(new Date(schema.maximum), locale, {
+                        timeZone: 'UTC',
+                        dateStyle: 'long'
+                    })
+                })
+                : undefined
+        };
+        return __assign(__assign({}, formattedMessages), dateOverrides);
+    }
+    return formattedMessages;
+}
+export default ControlFeedback;

package/build/legacy/jsonSchemaForm/controlFeedback/index.js

@@ -0,0 +1 @@
+export { default } from './ControlFeedback';

package/build/legacy/jsonSchemaForm/genericSchema/GenericSchema.js

@@ -0,0 +1,85 @@
+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);
+};
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { getSchemaType, isBasicError, isNullableBasicModel, isNullableObjectModel, isNullableArrayModel, isNullableStringModel, isObjectModel, isAllOfSchema, isOneOfSchema, isObjectSchema, isArraySchema, isPersistAsyncSchema, isValidationAsyncSchema, isBasicSchema, isOneOfObjectSchema, } from '../../common/utils';
+import AllOfSchema from '../allOfSchema';
+import ArraySchema from '../arrayTypeSchema';
+import BasicTypeSchema from '../basicTypeSchema';
+import ObjectSchema from '../objectSchema';
+import OneOfSchema from '../oneOfSchema';
+import PersistAsyncSchema from '../persistAsyncSchema';
+import PromotedOneOfSchema from '../promotedOneOfSchema';
+import ReadOnlySchema from '../readOnlySchema';
+import ValidationAsyncSchema from '../validationAsyncSchema';
+import { useLogger } from '../../common/contexts';
+function GenericSchemaForm(props) {
+    var schema = props.schema, _a = props.model, model = _a === void 0 ? null : _a, _b = props.errors, errors = _b === void 0 ? null : _b, _c = props.hideTitle, hideTitle = _c === void 0 ? false : _c, _d = props.disabled, disabled = _d === void 0 ? false : _d;
+    var schemaProps = __assign(__assign({}, props), { model: model, errors: errors, hideTitle: hideTitle, disabled: disabled });
+    var type = getSchemaType(schema);
+    var log = useLogger();
+    useEffect(function () {
+        if (!isValidGenericSchema(schema, model, errors)) {
+            log.error('Invalid schema or model', "Schema of type ".concat(type || 'undefined', " requested, but schema did not pass validation."));
+        }
+    }, [JSON.stringify(schema), JSON.stringify(model), JSON.stringify(errors), type, log]);
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (type) {
+        case 'readOnly':
+            return _jsx(ReadOnlySchema, __assign({}, schemaProps));
+        case 'persistAsync':
+            return _jsx(PersistAsyncSchema, __assign({}, schemaProps));
+        case 'validationAsync':
+            return _jsx(ValidationAsyncSchema, __assign({}, schemaProps));
+        case 'basic': {
+            var basicTypeProps = __assign({ infoMessage: null }, schemaProps);
+            return _jsx(BasicTypeSchema, __assign({}, basicTypeProps));
+        }
+        case 'object':
+            return _createElement(ObjectSchema, __assign({}, schemaProps, { key: JSON.stringify(schema) }));
+        case 'array':
+            return _jsx(ArraySchema, __assign({}, schemaProps));
+        case 'promotedOneOf':
+            return _jsx(PromotedOneOfSchema, __assign({}, schemaProps));
+        case 'oneOf':
+            return _jsx(OneOfSchema, __assign({}, schemaProps));
+        case 'allOf':
+            return _jsx(AllOfSchema, __assign({}, schemaProps));
+    }
+    return _jsx(_Fragment, {});
+}
+export default GenericSchemaForm;
+// TODO: MC-3224 - We want to implement proper schema validation
+var isValidGenericSchema = function (schema, model, errors) {
+    var type = getSchemaType(schema);
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (type) {
+        case 'persistAsync':
+            return isPersistAsyncSchema(schema) && isNullableStringModel(model) && isBasicError(errors);
+        case 'validationAsync':
+            return isValidationAsyncSchema(schema) && isNullableBasicModel(model) && isBasicError(errors);
+        case 'basic':
+            return isBasicSchema(schema) && isNullableBasicModel(model) && isBasicError(errors);
+        case 'object':
+            return isObjectSchema(schema) && isNullableObjectModel(model);
+        case 'array':
+            return isArraySchema(schema) && isNullableArrayModel(model) && isBasicError(errors);
+        case 'promotedOneOf':
+            return isOneOfObjectSchema(schema) && isNullableObjectModel(model);
+        case 'oneOf':
+            return isOneOfSchema(schema);
+        case 'allOf':
+            return isAllOfSchema(schema) && isObjectModel(model);
+    }
+    return false;
+};

package/build/legacy/jsonSchemaForm/genericSchema/index.js

@@ -0,0 +1 @@
+export { default } from './GenericSchema';

package/build/legacy/jsonSchemaForm/help/Help.js

@@ -0,0 +1,20 @@
+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);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Markdown, Info } from '@transferwise/components';
+import { useIntl } from 'react-intl';
+import helpMessages from '../../../common/messages/help.messages';
+function Help(props) {
+    var intl = useIntl();
+    return (_jsx(Info, { className: "m-l-1", content: _jsx(Markdown, __assign({ config: { link: { target: '_blank' } } }, { children: props.help.markdown })), presentation: "POPOVER", size: "sm", "aria-label": intl.formatMessage(helpMessages.helpAria) }));
+}
+export default Help;

package/build/legacy/jsonSchemaForm/help/index.js

@@ -0,0 +1 @@
+export { default } from './Help';

package/build/legacy/jsonSchemaForm/index.js

@@ -0,0 +1 @@
+export { default } from './JsonSchemaForm';

package/build/legacy/jsonSchemaForm/objectSchema/ObjectSchema.js

@@ -0,0 +1,77 @@
+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 __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 { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Header } from '@transferwise/components';
+import classNames from 'classnames';
+import { useState, useEffect } from 'react';
+import { isEqual } from '../../common/utils';
+import { getValidObjectModelParts } from '../../common/validators';
+import { DynamicAlert } from '../../layout';
+import GenericSchema from '../genericSchema';
+var getSchemaColumnClasses = function (width) { return ({
+    'col-xs-12': true,
+    'col-sm-6': width === 'md',
+    'col-sm-4': width === 'sm'
+}); };
+function ObjectSchema(props) {
+    var _a = useState(function () { return (__assign({}, getValidObjectModelParts(props.model, props.schema))); }), model = _a[0], setModel = _a[1];
+    var onChangeProperty = function (propertyName, onChangeProps) {
+        if (onChangeProps.model !== null) {
+            // FIXME we should not mutate the model here
+            model[propertyName] = onChangeProps.model;
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete model[propertyName];
+        }
+        setModel(model);
+        props.onChange(__assign(__assign({}, onChangeProps), { model: model }));
+    };
+    var isRequired = function (propertyName) {
+        return props.schema.required && props.schema.required.includes(propertyName);
+    };
+    useEffect(function () {
+        // When the schema changes, only retain valid parts of the model
+        var newModel = getValidObjectModelParts(model, props.schema) || {};
+        setModel(newModel);
+        if (!isEqual(newModel, model)) {
+            props.onChange({
+                model: newModel,
+                triggerSchema: props.schema,
+                triggerModel: newModel
+            });
+        }
+    }, [props.schema]);
+    var allorderedPropertiesSet = new Set(__spreadArray(__spreadArray([], (props.schema.displayOrder || []), true), Object.keys(props.schema.properties), true));
+    var isPropertyDefined = function (propertyName) {
+        return typeof props.schema.properties[propertyName] !== 'undefined';
+    };
+    // eslint-disable-next-line unicorn/prefer-spread
+    var orderedPropertyNames = Array.from(allorderedPropertiesSet).filter(isPropertyDefined);
+    // TODO: LOW avoid type assertion -- what happens when props.errors is not an object?
+    var propsErrors = props.errors;
+    return (_jsxs(_Fragment, { children: [props.schema.alert && _jsx(DynamicAlert, { component: props.schema.alert }), _jsxs("fieldset", { children: [props.schema.title && !props.hideTitle && (_jsx(Header, { title: props.schema.title, as: "legend" })), props.schema.description && !props.hideTitle && _jsxs("p", { children: [" ", props.schema.description, " "] }), _jsx("div", __assign({ className: "row" }, { children: orderedPropertyNames.map(function (propertyName) { return (_jsx("div", __assign({ className: classNames(getSchemaColumnClasses(props.schema.properties[propertyName].width)) }, { children: _jsx(GenericSchema, { schema: props.schema.properties[propertyName], model: props.model && props.model[propertyName], errors: propsErrors === null || propsErrors === void 0 ? void 0 : propsErrors[propertyName], submitted: props.submitted, required: isRequired(propertyName), disabled: props.disabled, onChange: function (onChangeProps) { return onChangeProperty(propertyName, onChangeProps); }, onPersistAsync: props.onPersistAsync }) }), propertyName)); }) }))] })] }));
+}
+ObjectSchema.defaultProps = {
+    hideTitle: false,
+    disabled: false
+};
+export default ObjectSchema;

package/build/legacy/jsonSchemaForm/objectSchema/index.js

@@ -0,0 +1 @@
+export { default } from './ObjectSchema';