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

package/build/legacy/dynamicFlow/utils/useDynamicFlowState.js

@@ -0,0 +1,137 @@
+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 { useMemo, useState } from 'react';
+import { isValidSchema, getValidObjectModelParts } from '../../common/validators';
+export var useDynamicFlowState = function (initialStep) {
+    var _a, _b;
+    var _c = useState((_a = initialStep === null || initialStep === void 0 ? void 0 : initialStep.errors) === null || _a === void 0 ? void 0 : _a.validation), formErrors = _c[0], setFormErrors = _c[1];
+    var _d = useState((_b = initialStep === null || initialStep === void 0 ? void 0 : initialStep.errors) === null || _b === void 0 ? void 0 : _b.error), globalError = _d[0], setGlobalError = _d[1];
+    var _e = useState({
+        step: initialStep || undefined,
+        models: (initialStep === null || initialStep === void 0 ? void 0 : initialStep.model)
+            ? buildInitialModels(initialStep.model, getAllSchemas(initialStep))
+            : {},
+        etag: undefined
+    }), stepAndModels = _e[0], setStepAndModels = _e[1];
+    var step = stepAndModels.step, models = stepAndModels.models, etag = stepAndModels.etag;
+    var setStepAndEtag = function (step, etag) {
+        var _a, _b, _c, _d;
+        setStepAndModels({
+            step: step,
+            models: step.model ? buildInitialModels(step.model, getAllSchemas(step)) : {},
+            etag: etag
+        });
+        setFormErrors((_b = (_a = step === null || step === void 0 ? void 0 : step.errors) === null || _a === void 0 ? void 0 : _a.validation) !== null && _b !== void 0 ? _b : null);
+        setGlobalError((_d = (_c = step === null || step === void 0 ? void 0 : step.errors) === null || _c === void 0 ? void 0 : _c.error) !== null && _d !== void 0 ? _d : null);
+    };
+    var setSchemaModel = function (schemaId, objectModel, onModelsUpdated) {
+        setStepAndModels(function (previous) {
+            var _a;
+            var updatedModels = __assign(__assign({}, previous.models), (_a = {}, _a[schemaId] = objectModel, _a));
+            var updatedState = {
+                step: previous.step,
+                models: updatedModels,
+                etag: previous.etag
+            };
+            onModelsUpdated(updatedModels);
+            return updatedState;
+        });
+    };
+    var modelIsValid = useMemo(function () { return areModelsValid(models, getAllValidatableSchemas(step)); }, [models, step]);
+    return {
+        formErrors: formErrors,
+        globalError: globalError,
+        step: step,
+        models: models,
+        etag: etag,
+        modelIsValid: modelIsValid,
+        setFormErrors: setFormErrors,
+        setGlobalError: setGlobalError,
+        setStepAndEtag: setStepAndEtag,
+        setSchemaModel: setSchemaModel
+    };
+};
+var buildInitialModels = function (model, schemas) {
+    if (schemas === void 0) { schemas = []; }
+    return schemas.reduce(function (acc, schema) {
+        var _a;
+        if (!schema.$id) {
+            // TODO: DF-473 - Remove type assertions once we're confident people have had time to fix any errors
+            // eslint-disable-next-line no-console
+            console.warn('Schema without $id property found.');
+        }
+        return __assign(__assign({}, acc), (_a = {}, _a[schema.$id || ''] = getValidObjectModelParts(model, schema) || {}, _a));
+    }, {});
+};
+var getAllSchemas = function (step) { return __spreadArray(__spreadArray([], getAllSchemasInLayout((step === null || step === void 0 ? void 0 : step.layout) || []), true), ((step === null || step === void 0 ? void 0 : step.schemas) || []), true); };
+var getAllSchemasInLayout = function (components) {
+    return components.flatMap(function (component) {
+        switch (component.type) {
+            case 'columns':
+                return __spreadArray([], getAllSchemasInLayout(__spreadArray(__spreadArray([], component.left, true), component.right, true)), true);
+            case 'box':
+                return getAllSchemasInLayout(component.components);
+            case 'form':
+                return isInlineSchema(component.schema) ? [component.schema] : [];
+            default:
+                return [];
+        }
+    });
+};
+var getAllValidatableSchemas = function (step) { return __spreadArray(__spreadArray([], getAllReferencedSchemaIds((step === null || step === void 0 ? void 0 : step.layout) || [])
+    .map(function (id) { return ((step === null || step === void 0 ? void 0 : step.schemas) || []).find(function (schema) { return schema.$id === id; }); })
+    .filter(Boolean), true), getAllSchemasInLayout((step === null || step === void 0 ? void 0 : step.layout) || []), true); };
+var getAllReferencedSchemaIds = function (components) {
+    return components
+        .flatMap(function (component) {
+        switch (component.type) {
+            case 'columns':
+                return __spreadArray([], getAllReferencedSchemaIds(__spreadArray(__spreadArray([], component.left, true), component.right, true)), true);
+            case 'box':
+                return getAllReferencedSchemaIds(component.components);
+            case 'form':
+                return [getSchemaReference(component)];
+            default:
+                return [];
+        }
+    })
+        .filter(Boolean);
+};
+var areModelsValid = function (formModels, schemas) {
+    if (schemas === void 0) { schemas = []; }
+    return !(schemas === null || schemas === void 0 ? void 0 : schemas.some(function (schema) {
+        if (!schema.$id) {
+            // TODO: DF-473
+            // eslint-disable-next-line no-console
+            console.warn('Schema without $id property found.');
+        }
+        return !isValidSchema(formModels[schema.$id || ''] || {}, schema);
+    }));
+};
+var getSchemaReference = function (component) {
+    if (component.schema && !isInlineSchema(component.schema)) {
+        return component.schema.$ref;
+    }
+    return component.schemaId;
+};
+var isInlineSchema = function (schema) {
+    return schema !== undefined && typeof schema === 'object' && !Object.hasOwnProperty.call(schema, '$ref');
+};

package/build/legacy/dynamicFlow/utils/useLoader.js

@@ -0,0 +1,22 @@
+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 { Loader, Size } from '@transferwise/components';
+import { useState } from 'react';
+export function useLoader(loaderConfig, initialState) {
+    var config = __assign({ size: Size.EXTRA_LARGE, initial: true, submission: false }, loaderConfig);
+    var _a = useState(initialState), loadingState = _a[0], setLoadingState = _a[1];
+    var shouldDisplayLoader = (config.initial && loadingState === 'initial') ||
+        (config.submission && loadingState === 'submission');
+    var loader = shouldDisplayLoader ? (_jsx(Loader, { size: config.size, classNames: { 'tw-loader': 'tw-loader m-x-auto' }, "data-testid": "loader" })) : null;
+    return { isLoading: loadingState !== 'idle', setLoadingState: setLoadingState, loader: loader };
+}

package/build/legacy/formControl/FormControl.js

@@ -0,0 +1,266 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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, Fragment as _Fragment } from "react/jsx-runtime";
+import { Checkbox, DateInput, DateLookup, InputWithDisplayFormat, PhoneNumberInput, RadioGroup, SelectInput, SelectInputOptionContent, Tabs, TextareaWithDisplayFormat, Upload, } from '@transferwise/components';
+import { PureComponent } from 'react';
+import { DateMode, FormControlType, MonthFormat, Size } from '../common/constants';
+import { dateToDateString } from '../common/utils';
+import { isArray, isNumber, isString } from '../common/validators';
+import { getSafeStringOrNumberValue, getSafeDateOrStringValue, getSafeDateStringValue, getSafeStringValue, getSafeBooleanValue, getAutocompleteString, } from './utils';
+var FormControl = /** @class */ (function (_super) {
+    __extends(FormControl, _super);
+    function FormControl(props) {
+        var _this = _super.call(this, props) || this;
+        _this.getAutocompleteValue = function (_a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b.prefix, prefix = _c === void 0 ? '' : _c, _d = _b.suffix, suffix = _d === void 0 ? '' : _d;
+            var _e = _this.props, autoComplete = _e.autoComplete, autocompleteHint = _e.autocompleteHint;
+            if (isArray(autocompleteHint)) {
+                return getAutocompleteString(autocompleteHint, { prefix: prefix, suffix: suffix });
+            }
+            return autoComplete ? 'on' : 'off';
+        };
+        _this.handleOnChange = function (value, metadata) {
+            _this.props.onChange(value, undefined, metadata);
+        };
+        _this.handleInputOnChange = function (event) {
+            _this.props.onChange(event.target.value);
+        };
+        _this.handleOnFocus = function () {
+            var _a, _b;
+            (_b = (_a = _this.props).onFocus) === null || _b === void 0 ? void 0 : _b.call(_a);
+        };
+        _this.handleOnBlur = function () {
+            var _a, _b;
+            (_b = (_a = _this.props).onBlur) === null || _b === void 0 ? void 0 : _b.call(_a);
+        };
+        _this.getSelectedOption = function (options) {
+            if (_this.state.selectedOption !== null && typeof _this.state.selectedOption !== 'undefined') {
+                return options.find(function (option) { var _a; return ((_a = _this.state.selectedOption) === null || _a === void 0 ? void 0 : _a.value) === option.value; });
+            }
+            if (_this.props.value !== null && typeof _this.props.value !== 'undefined') {
+                return options.find(function (option) { return _this.props.value === option.value; });
+            }
+            return undefined;
+        };
+        _this.mapOption = function (option) { return (__assign(__assign({}, option), { value: isNumber(option.value) || isString(option.value) ? option.value : undefined, secondary: option.note, disabled: option.disabled || _this.props.disabled, readOnly: _this.props.readOnly })); };
+        _this.state = {
+            selectedOption: props.selectedOption,
+            touched: false,
+            prevValue: props.value
+        };
+        return _this;
+    }
+    FormControl.getDerivedStateFromProps = function (nextProps, previousState) {
+        if (previousState.prevValue !== nextProps.value) {
+            return { prevValue: nextProps.value, value: nextProps.value };
+        }
+        return null;
+    };
+    FormControl.prototype.render = function () {
+        var _this = this;
+        var _a, _b;
+        var _c = this.props, name = _c.name, placeholder = _c.placeholder, step = _c.step, countryCode = _c.countryCode, type = _c.type, options = _c.options, disabled = _c.disabled, readOnly = _c.readOnly, required = _c.required, minLength = _c.minLength, maxLength = _c.maxLength, min = _c.min, max = _c.max, searchPlaceholder = _c.searchPlaceholder, onSearchChange = _c.onSearchChange, size = _c.size, uploadProps = _c.uploadProps, label = _c.label, monthFormat = _c.monthFormat, 
+        // FIXME pass id to all components that accept it
+        id = _c.id, minDate = _c.minDate, maxDate = _c.maxDate, value = _c.value, mode = _c.mode, describedBy = _c.describedBy;
+        switch (type) {
+            case FormControlType.RADIO:
+                return (_jsx(RadioGroup, { radios: options.map(this.mapOption), name: name, selectedValue: getSafeStringOrNumberValue(value, { coerceValue: true }), onChange: this.handleOnChange }));
+            case FormControlType.CHECKBOX:
+                return (_jsx(Checkbox, { checked: getSafeBooleanValue(value, { coerceValue: true }), disabled: disabled, label: label, required: required, readOnly: readOnly, onChange: this.handleOnChange, onBlur: this.handleOnBlur, onFocus: this.handleOnFocus }));
+            case FormControlType.SELECT: {
+                var search = options.length >= 8;
+                var items = options;
+                var selected = this.getSelectedOption(options);
+                return (_jsx("div", __assign({ className: "d-flex flex-column" }, { children: _jsx(SelectInput, { id: id, items: items.map(function (value) { return ({
+                            type: 'option',
+                            value: value,
+                            disabled: value.disabled
+                        }); }), value: (_a = selected) !== null && _a !== void 0 ? _a : null, renderValue: function (_a, withinTrigger) {
+                            var hideIconInTrigger = _a.hideIconInTrigger, icon = _a.icon, label = _a.label, note = _a.note, secondary = _a.secondary;
+                            return (_jsx(SelectInputOptionContent, { title: label, note: note !== null && note !== void 0 ? note : secondary, icon: withinTrigger && hideIconInTrigger ? undefined : icon }));
+                        }, filterable: search, disabled: disabled, placeholder: placeholder, filterPlaceholder: searchPlaceholder, onChange: function (option) {
+                            var _a;
+                            _this.setState({ selectedOption: option });
+                            _this.props.onChange((_a = option === null || option === void 0 ? void 0 : option.value) !== null && _a !== void 0 ? _a : null);
+                        }, onFilterChange: search && onSearchChange
+                            ? function (_a) {
+                                var query = _a.query;
+                                onSearchChange(query);
+                            }
+                            : undefined, onClear: function () {
+                            _this.setState({ selectedOption: null });
+                            _this.props.onChange(null);
+                        } }) })));
+            }
+            case FormControlType.TAB:
+                return (_jsx(Tabs, { selected: (((_b = this.getSelectedOption(options)) === null || _b === void 0 ? void 0 : _b.value) || 0), tabs: options.map(function (option) { return ({
+                        title: option.label,
+                        content: _jsx(_Fragment, {}),
+                        disabled: option.disabled || false
+                    }); }), name: id, onTabSelect: function (index) {
+                        var hasSelectedOption = !!_this.state.selectedOption;
+                        _this.setState({
+                            selectedOption: options.find(function (option) { return option.value === index; })
+                        });
+                        _this.props.onChange(index, hasSelectedOption ? 'user' : 'init');
+                    } }));
+            case FormControlType.NUMERIC:
+            case FormControlType.NUMBER: {
+                return (_jsx("input", { autoComplete: this.getAutocompleteValue(), className: "form-control", disabled: disabled, id: id, max: max, min: min, placeholder: placeholder, readOnly: readOnly, required: required, step: step, type: "number", value: getSafeStringOrNumberValue(value, { coerceValue: true }), "aria-describedby": describedBy, onBlur: this.handleOnBlur, onChange: function (event) {
+                        if (type === FormControlType.NUMERIC) {
+                            _this.props.onChange(event.target.value);
+                        }
+                        else {
+                            // Input type number target value is a string and needs to be a number
+                            _this.props.onChange(parseFloat(event.target.value));
+                            // FIXME: maybe this parsing should be done outside of this component in SchemaFormControl,
+                            // where we know what schema we're working with?
+                        }
+                    }, onFocus: this.handleOnFocus, onWheel: function (event) {
+                        if (event.target instanceof HTMLElement) {
+                            // To prevent values being changed when input is focussed and user scrolls
+                            event.target.blur();
+                        }
+                    } }));
+            }
+            case FormControlType.HIDDEN:
+                return (_jsx("input", { type: "hidden", name: name, value: getSafeStringValue(value, { coerceValue: true }), id: id }));
+            case FormControlType.PASSWORD:
+                return (_jsx("input", { autoComplete: this.getAutocompleteValue(), className: "form-control", disabled: disabled, id: id, placeholder: placeholder, readOnly: readOnly, required: required, type: "password", value: getSafeStringValue(value, { coerceValue: true }), "aria-describedby": describedBy, onBlur: this.handleOnBlur, onChange: this.handleInputOnChange, onFocus: this.handleOnFocus }));
+            case FormControlType.DATE:
+            case FormControlType.DATETIME:
+                return (_jsx(DateInput, { dayAutoComplete: this.getAutocompleteValue({ suffix: '-day' }), yearAutoComplete: this.getAutocompleteValue({ suffix: '-year' }), disabled: disabled, size: size, value: getSafeDateOrStringValue(value), mode: mode, monthFormat: monthFormat, onBlur: this.handleOnBlur, onChange: this.handleOnChange, onFocus: this.handleOnFocus }));
+            case FormControlType.DATELOOKUP: {
+                return (_jsx(DateLookup
+                // DateLookup handles null values perfectly well, it's just typed incorrectly
+                , { 
+                    // DateLookup handles null values perfectly well, it's just typed incorrectly
+                    value: getSafeDateStringValue(value), min: minDate, max: maxDate, placeholder: placeholder, monthFormat: monthFormat, disabled: disabled, onChange: function (date) {
+                        // FIXME We need types for DateLookup
+                        _this.handleOnChange(dateToDateString(date));
+                    }, onBlur: this.handleOnBlur, onFocus: this.handleOnFocus }));
+            }
+            case FormControlType.TEL:
+                return (_jsx(PhoneNumberInput, { disabled: disabled, countryCode: countryCode, placeholder: placeholder, required: required, searchPlaceholder: searchPlaceholder, size: size, initialValue: getSafeStringValue(value), onBlur: this.handleOnBlur, onChange: function (value) { return _this.handleOnChange(value); }, onFocus: this.handleOnFocus }));
+            case FormControlType.TEXTAREA: {
+                var textareaProps = {
+                    className: 'form-control tw-form-control',
+                    id: id,
+                    name: name,
+                    placeholder: placeholder,
+                    value: getSafeStringValue(value, { coerceValue: true }),
+                    readOnly: readOnly,
+                    required: required,
+                    minLength: minLength,
+                    maxLength: maxLength,
+                    onFocus: this.handleOnFocus,
+                    onBlur: this.handleOnBlur,
+                    disabled: disabled,
+                    autoComplete: this.getAutocompleteValue()
+                };
+                if (this.props.displayPattern) {
+                    return (_jsx(TextareaWithDisplayFormat, __assign({ displayPattern: this.props.displayPattern }, textareaProps, { onChange: this.handleOnChange })));
+                }
+                return (_jsx("textarea", __assign({}, textareaProps, { "aria-describedby": describedBy, onChange: this.handleInputOnChange })));
+            }
+            case FormControlType.FILE:
+            case FormControlType.UPLOAD: {
+                return (
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-expect-error - TODO: Remove this once Upload is migrated to TypeScript
+                _jsx(Upload, __assign({}, uploadProps, { usAccept: uploadProps.usAccept || '*', usDisabled: uploadProps.usDisabled || disabled, onSuccess: function (base64url, filename) {
+                        _this.handleOnChange(base64url, { filename: filename });
+                    }, onFailure: function () {
+                        _this.handleOnChange(null);
+                    }, onCancel: function () {
+                        _this.handleOnChange(null);
+                    } })));
+            }
+            case FormControlType.TEXT:
+            case FormControlType.EMAIL:
+            default: {
+                var inputProps = {
+                    type: type === FormControlType.EMAIL ? 'email' : 'text',
+                    className: 'form-control',
+                    id: id,
+                    name: name,
+                    placeholder: placeholder,
+                    value: getSafeStringValue(value, { coerceValue: true }),
+                    readOnly: readOnly,
+                    required: required,
+                    minLength: minLength,
+                    maxLength: maxLength,
+                    onFocus: this.handleOnFocus,
+                    onBlur: this.handleOnBlur,
+                    disabled: disabled,
+                    autoComplete: this.getAutocompleteValue()
+                };
+                if (this.props.displayPattern) {
+                    return (_jsx(InputWithDisplayFormat, __assign({ displayPattern: this.props.displayPattern }, inputProps, { onChange: this.handleOnChange })));
+                }
+                return (_jsx("input", __assign({}, inputProps, { "aria-describedby": describedBy, onChange: this.handleInputOnChange })));
+            }
+        }
+    };
+    FormControl.Type = FormControlType;
+    FormControl.Size = Size;
+    FormControl.MonthFormat = MonthFormat;
+    FormControl.DateMode = DateMode;
+    FormControl.defaultProps = {
+        autoComplete: true,
+        countryCode: null,
+        disabled: false,
+        displayPattern: null,
+        id: null,
+        label: '',
+        max: null,
+        maxDate: null,
+        maxLength: null,
+        min: null,
+        minDate: null,
+        minLength: null,
+        mode: FormControl.DateMode.DAY_MONTH_YEAR,
+        monthFormat: FormControl.MonthFormat.LONG,
+        onBlur: null,
+        onFocus: null,
+        onSearchChange: null,
+        options: [],
+        placeholder: null,
+        readOnly: false,
+        required: false,
+        searchPlaceholder: null,
+        searchValue: '',
+        selectedOption: null,
+        size: FormControl.Size.MEDIUM,
+        step: 1,
+        type: FormControl.Type.TEXT,
+        uploadProps: {},
+        value: null
+    };
+    return FormControl;
+}(PureComponent));
+export default FormControl;

package/build/legacy/formControl/index.js

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

package/build/legacy/formControl/utils/getAutocompleteString.js

@@ -0,0 +1,80 @@
+export var getAutocompleteString = function (hints, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.prefix, prefix = _c === void 0 ? '' : _c, _d = _b.suffix, suffix = _d === void 0 ? '' : _d;
+    var autoCompleteString = hints
+        .map(function (hint) {
+        var builtHint = "".concat(prefix).concat(hint).concat(suffix);
+        return isAutocompleteToken(builtHint) ? autocompleteTokenMap[builtHint] : undefined;
+    })
+        .filter(function (str) { return str; })
+        .join(' ');
+    return autoCompleteString || 'off';
+};
+var isAutocompleteToken = function (str) {
+    return Object.keys(autocompleteTokenMap).some(function (hint) { return hint === str; });
+};
+var autocompleteTokenMap = {
+    on: 'on',
+    name: 'name',
+    'name-prefix': 'honorific-prefix',
+    'given-name': 'given-name',
+    'additional-name': 'additional-name',
+    'family-name': 'family-name',
+    'name-suffix': 'honorific-suffix',
+    nickname: 'nickname',
+    email: 'email',
+    // Web doesn't have a specific mapping for new username, but this is semantically close enough
+    'new-username': 'username',
+    username: 'username',
+    'new-password': 'new-password',
+    password: 'current-password',
+    'one-time-code': 'one-time-code',
+    'job-title': 'organization-title',
+    'organization-name': 'organization',
+    'full-street-address': 'street-address',
+    'street-address-line-1': 'address-line1',
+    'street-address-line-2': 'address-line2',
+    'street-address-line-3': 'address-line3',
+    'address-level-1': 'address-level1',
+    'address-level-2': 'address-level2',
+    'address-level-3': 'address-level3',
+    'address-level-4': 'address-level4',
+    'country-code': 'country',
+    'country-name': 'country-name',
+    'postal-code': 'postal-code',
+    'credit-card-name': 'cc-name',
+    'credit-card-given-name': 'cc-given-name',
+    'credit-card-middle-name': 'cc-additional-name',
+    'credit-card-family-name': 'cc-family-name',
+    'credit-card-number': 'cc-number',
+    'credit-card-expiration': 'cc-exp',
+    'credit-card-expiration-month': 'cc-exp-month',
+    'credit-card-expiration-year': 'cc-exp-year',
+    'credit-card-security-code': 'cc-csc',
+    'credit-card-type': 'cc-type',
+    'transaction-currency': 'transaction-currency',
+    'transaction-amount': 'transaction-amount',
+    language: 'language',
+    birthdate: 'bday',
+    'birthdate-day': 'bday-day',
+    'birthdate-month': 'bday-month',
+    'birthdate-year': 'bday-year',
+    gender: 'sex',
+    'phone-number': 'tel',
+    'phone-country-code': 'tel-country-code',
+    'phone-national': 'tel-national',
+    'phone-area-code': 'tel-area-code',
+    'phone-local': 'tel-local',
+    'phone-local-prefix': 'tel-local-prefix',
+    'phone-local-suffix': 'tel-local-suffix',
+    'phone-extension': 'tel-extension',
+    url: 'url',
+    photo: 'photo',
+    impp: 'impp',
+    shipping: 'shipping',
+    billing: 'billing',
+    home: 'home',
+    work: 'work',
+    mobile: 'mobile',
+    fax: 'fax',
+    pager: 'pager'
+};

package/build/legacy/formControl/utils/index.js

@@ -0,0 +1,2 @@
+export * from './value-utils';
+export { getAutocompleteString } from './getAutocompleteString';

package/build/legacy/formControl/utils/value-utils.js

@@ -0,0 +1,108 @@
+/* eslint-disable no-console */
+import { dateStringToDate } from '../../common/utils';
+import { isBoolean, isNull, isNumber, isObject, isString } from '../../common/validators';
+export var getSafeStringValue = function (value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.coerceValue, coerceValue = _a === void 0 ? false : _a;
+    if (isNull(value)) {
+        return undefined;
+    }
+    if (isObject(value)) {
+        logInvalidTypeFallbackWarning({ received: 'object', expected: 'string' });
+        return undefined;
+    }
+    if (!isString(value)) {
+        if (coerceValue) {
+            // TODO: Remove this coercion once we're sure everyone has had a chance to address warnings
+            logInvalidTypeCoercedWarning({ received: typeof value, expected: 'string' });
+            return String(value);
+        }
+        else {
+            logInvalidTypeFallbackWarning({ received: typeof value, expected: 'string' });
+            return undefined;
+        }
+    }
+    return value;
+};
+export var getSafeStringOrNumberValue = function (value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.coerceValue, coerceValue = _a === void 0 ? false : _a;
+    if (isNull(value)) {
+        return undefined;
+    }
+    if (isNumber(value)) {
+        return value;
+    }
+    var logProps = { received: typeof value, expected: 'string or number' };
+    if (isObject(value)) {
+        logInvalidTypeFallbackWarning(logProps);
+        return undefined;
+    }
+    if (!isString(value)) {
+        if (coerceValue) {
+            // TODO: Remove this coercion once we're sure everyone has had a chance to address warnings
+            logInvalidTypeCoercedWarning(logProps);
+            return String(value);
+        }
+        else {
+            logInvalidTypeFallbackWarning(logProps);
+            return undefined;
+        }
+    }
+    return value;
+};
+export var getSafeBooleanValue = function (value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.coerceValue, coerceValue = _a === void 0 ? false : _a;
+    if (isNull(value)) {
+        return false;
+    }
+    if (!isBoolean(value)) {
+        if (coerceValue) {
+            // TODO: Remove this coercion once we're sure everyone has had a chance to address warnings
+            logInvalidTypeCoercedWarning({ received: typeof value, expected: 'boolean' });
+            return Boolean(value);
+        }
+        else {
+            logInvalidTypeFallbackWarning({ received: typeof value, expected: 'boolean' });
+            return undefined;
+        }
+    }
+    return value;
+};
+export var getSafeDateOrStringValue = function (value) {
+    if (isNull(value)) {
+        return undefined;
+    }
+    if (!(value instanceof Date) && !isString(value)) {
+        logInvalidTypeFallbackWarning({ received: typeof value, expected: 'string or Date' });
+        return undefined;
+    }
+    return value;
+};
+export var getSafeDateStringValue = function (value) {
+    if (isNull(value)) {
+        return null;
+    }
+    if (!isString(value)) {
+        logInvalidTypeFallbackWarning({
+            received: typeof value,
+            expected: 'string',
+            fallback: 'null'
+        });
+        return null;
+    }
+    var date = dateStringToDate(value);
+    if (date === null) {
+        console.warn('Incorrectly formatted date string. Falling back to null.');
+    }
+    return date;
+};
+var logInvalidTypeCoercedWarning = function (_a) {
+    var received = _a.received, expected = _a.expected;
+    console.warn("Value with type ".concat(received, " passed to control that only accepts type ").concat(expected, ". Type will be coerced, but this behaviour will change in the future, so please fix your code."));
+};
+var logInvalidTypeFallbackWarning = function (_a) {
+    var received = _a.received, expected = _a.expected, _b = _a.fallback, fallback = _b === void 0 ? 'undefined' : _b;
+    console.warn("Value with type ".concat(received, " passed to control that only accepts type ").concat(expected, ". Falling back to ").concat(fallback));
+};

package/build/legacy/jsonSchemaForm/JsonSchemaForm.js

@@ -0,0 +1,24 @@
+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 { LogProvider, EventsContextProvider } from '../common/contexts';
+import GenericSchema from './genericSchema';
+import { HttpClientProviderFromBaseUrl } from '../../common/httpClientContext';
+function JsonSchemaForm(props) {
+    var schemaProps = __assign({ model: null, errors: null }, props);
+    var _a = props.baseUrl, baseUrl = _a === void 0 ? '' : _a, _b = props.onEvent, onEvent = _b === void 0 ? noop : _b, _c = props.onLog, onLog = _c === void 0 ? noop : _c;
+    return (_jsx(LogProvider, __assign({ flowId: "JsonSchemaForm", stepId: "JsonSchemaForm", onLog: onLog }, { children: _jsx(EventsContextProvider, __assign({ metadata: { flowId: 'JsonSchemaForm', stepId: 'JsonSchemaForm' }, onEvent: onEvent }, { children: _jsx(HttpClientProviderFromBaseUrl, __assign({ baseUrl: baseUrl }, { children: _jsx(GenericSchema, __assign({}, schemaProps)) })) })) })));
+}
+export default JsonSchemaForm;
+var noop = function () {
+    // noop
+};