@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/jsonSchemaForm/allOfSchema/AllOfSchema.js

@@ -0,0 +1,54 @@
+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, jsxs as _jsxs } from "react/jsx-runtime";
+import classNames from 'classnames';
+import { useState } from 'react';
+import { getValidObjectModelParts } from '../../common/validation/valid-model';
+import GenericSchema from '../genericSchema';
+var splitModel = function (model, schemas) {
+    // If wew receive a model, break it down to parts valid for each schema
+    return schemas.map(function (schema) { return getValidObjectModelParts(model, schema) || {}; });
+};
+var combineModels = function (models) {
+    return models.reduce(function (current, combined) {
+        return __assign(__assign({}, combined), current);
+    }, {});
+};
+var getSchemaColumnClasses = function (width) {
+    return {
+        'col-xs-12': true,
+        'col-sm-6': width === 'md',
+        'col-sm-4': width === 'sm'
+    };
+};
+var AllOfSchema = function (props) {
+    var onChangeModelIndex = function (index, onChangeProps) {
+        var modelSchema = props.schema.allOf[index];
+        // FIXME we should not mutate models here
+        // eslint-disable-next-line fp/no-mutation
+        models[index] = getValidObjectModelParts(onChangeProps.model, modelSchema) || {};
+        setModels(models);
+        props.onChange(__assign(__assign({}, onChangeProps), { model: combineModels(models) }));
+    };
+    var _a = useState(splitModel(props.model, props.schema.allOf)), models = _a[0], setModels = _a[1];
+    return (_jsxs(_Fragment, { children: [props.schema.title && _jsx("h3", __assign({ className: "page-header" }, { children: props.schema.title })), props.schema.description && _jsx("p", { children: props.schema.description }), _jsx("div", __assign({ className: "row" }, { children: props.schema.allOf.map(function (schema, index) { return (
+                // eslint-disable-next-line react/no-array-index-key
+                _jsx("div", __assign({ className: classNames(getSchemaColumnClasses(schema.width)) }, { children: _jsx(GenericSchema, { schema: schema, model: models[index], errors: props.errors, submitted: props.submitted, disabled: props.disabled, onChange: function (onChangeProps) {
+                            return onChangeModelIndex(index, __assign(__assign({}, onChangeProps), { 
+                                // We can safely assume that the model here is going to be of the same type as the model prop
+                                model: onChangeProps.model }));
+                        }, onPersistAsync: props.onPersistAsync }) }), index)); }) }))] }));
+};
+AllOfSchema.defaultProps = {
+    disabled: false
+};
+export default AllOfSchema;

package/build/jsonSchemaForm/allOfSchema/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './AllOfSchema';
+export type { AllOfSchemaProps } from './AllOfSchema';

package/build/jsonSchemaForm/allOfSchema/index.js

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

package/build/jsonSchemaForm/arrayTypeSchema/ArraySchema.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { ArrayModel, ArraySchema as ArraySchemaType } from '../../dynamic-flow-types';
+import { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare const ArraySchema: {
+    (props: ArraySchemaProps): JSX.Element;
+    defaultProps: {
+        required: boolean;
+    };
+};
+export type ArraySchemaProps = GenericSchemaProps & {
+    schema: ArraySchemaType;
+    model: ArrayModel | null;
+    errors: string | null;
+};
+export default ArraySchema;

package/build/jsonSchemaForm/arrayTypeSchema/ArraySchema.js

@@ -0,0 +1,25 @@
+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 { isListArraySchema, } from '../../dynamic-flow-types';
+import ArrayListSchema from './arrayListSchema/ArrayListSchema';
+var ArraySchema = function (props) {
+    var schema = props.schema;
+    if (isListArraySchema(schema)) {
+        return _jsx(ArrayListSchema, __assign({}, props));
+    }
+    throw new Error('Not implemented'); // Tuple not implemented
+};
+ArraySchema.defaultProps = {
+    required: false
+};
+export default ArraySchema;

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/ArrayListSchema.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { ArrayModel, ArraySchema as ArraySchemaType } from '../../../dynamic-flow-types';
+import { GenericSchemaProps } from '../../genericSchema/GenericSchema';
+declare const ArrayListSchema: {
+    (props: Props): JSX.Element;
+    defaultProps: {
+        errors: null;
+        required: boolean;
+    };
+};
+type Props = GenericSchemaProps & {
+    schema: ArraySchemaType;
+    errors?: string | null;
+    model: ArrayModel | null;
+};
+export default ArrayListSchema;

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/ArrayListSchema.js

@@ -0,0 +1,26 @@
+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 { isMultipleFileUploadSchema } from '../../../dynamic-flow-types/Schema';
+import MultipleFileUploadSchema from './multipleFileUploadSchema';
+var ArrayListSchema = function (props) {
+    var schema = props.schema;
+    if (isMultipleFileUploadSchema(schema)) {
+        return _jsx(MultipleFileUploadSchema, __assign({}, props, { schema: schema }));
+    }
+    throw new Error('Not implemented');
+};
+ArrayListSchema.defaultProps = {
+    errors: null,
+    required: false
+};
+export default ArrayListSchema;

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/index.d.ts

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

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

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

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/MultipleFileUploadSchema.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { ArrayModel } from '../../../../dynamic-flow-types';
+import { MultipleFileUploadSchema as MultipleFileUploadSchemaType } from '../../../../dynamic-flow-types/Schema';
+import { GenericSchemaProps } from '../../../genericSchema/GenericSchema';
+declare const MultipleFileUploadSchema: {
+    (props: Props): JSX.Element;
+    defaultProps: {
+        errors: null;
+        required: boolean;
+    };
+};
+type Props = Omit<GenericSchemaProps, 'model'> & {
+    schema: MultipleFileUploadSchemaType;
+    model: ArrayModel | null;
+    required?: boolean;
+    errors?: string | null;
+};
+export default MultipleFileUploadSchema;

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/MultipleFileUploadSchema.js

@@ -0,0 +1,141 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Status, UploadInput } from '@transferwise/components';
+import { isNumber, isString } from '@transferwise/neptune-validation';
+import classNames from 'classnames';
+import { useMemo, useState } from 'react';
+import { usePersistAsync } from '../../../../common/hooks/usePersistAsync';
+import { useTracking } from '../../../../common/tracking';
+import { areFilesSame, toKilobytes } from '../../../../common/utils/file-utils';
+import { generateRandomId } from '../../../../common/utils/generate-random-id';
+import { filterOutNull } from '../../../../common/validation/valid-model/utils';
+import { getArrayValidationFailures } from '../../../../common/validation/validation-failures';
+import { isBlobSchema, } from '../../../../dynamic-flow-types/Schema';
+import ControlFeedback from '../../../controlFeedback';
+import { useFormattedDefaultErrorMessages } from './useFormattedDefaultErrorMessages';
+import { constructUploadResponse, constructUploadError, createPayload } from './utils';
+var MultipleFileUploadSchema = function (props) {
+    var _a, _b;
+    var onChange = props.onChange, schema = props.schema;
+    var trackEvent = useTracking();
+    var defaultErrorMessages = useFormattedDefaultErrorMessages(schema);
+    var uid = useMemo(function () { return schema.$id || generateRandomId(); }, [schema.$id]);
+    var _c = useState(false), inputChanged = _c[0], setInputChanged = _c[1];
+    var _d = useState(function () { return convertFileIdsToComponentFileObjects(props.model || []); }), files = _d[0], setFiles = _d[1];
+    var performPersistAsync = usePersistAsync(schema.items.persistAsync);
+    var fileSchemaDescriptor = schema.items.persistAsync.schema;
+    var isBlob = isBlobSchema(fileSchemaDescriptor);
+    var uploadFile = function (userUploadedFile) { return __awaiter(void 0, void 0, void 0, function () {
+        var payload, response, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setInputChanged(true);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, createPayload(userUploadedFile, isBlob)];
+                case 2:
+                    payload = _a.sent();
+                    trackEvent('Dynamic Flow - PersistAsync', { status: 'pending', schemaId: schema.$id });
+                    return [4 /*yield*/, performPersistAsync(payload)];
+                case 3:
+                    response = _a.sent();
+                    trackEvent('Dynamic Flow - PersistAsync', { status: 'success', schemaId: schema.$id });
+                    return [2 /*return*/, constructUploadResponse(response)];
+                case 4:
+                    error_1 = _a.sent();
+                    trackEvent('Dynamic Flow - PersistAsync', { status: 'failure', schemaId: schema.$id });
+                    return [2 /*return*/, Promise.reject(constructUploadError(error_1))];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    function onFilesChange(newFiles) {
+        if (areFilesSame(newFiles, files)) {
+            return;
+        }
+        setFiles(newFiles);
+        var validFiles = getSuccessfullyProcessedFiles(newFiles);
+        var data = validFiles.map(function (file) { return file.id; });
+        onChange({
+            model: data,
+            triggerSchema: schema,
+            triggerModel: data
+        });
+    }
+    var validFiles = getSuccessfullyProcessedFiles(files);
+    var fileIds = validFiles.map(function (file) { return file.id; });
+    var fileListValidationFailures = getArrayValidationFailures(fileIds, schema, props.required);
+    var showError = Boolean(props.errors) ||
+        ((inputChanged || props.submitted) && Boolean(fileListValidationFailures.length));
+    var accepts = 'accepts' in fileSchemaDescriptor && fileSchemaDescriptor.accepts;
+    var maxSize = 'maxSize' in fileSchemaDescriptor && fileSchemaDescriptor.maxSize;
+    var uploadInputProps = __assign(__assign(__assign({ multiple: true, className: 'form-control', files: files, fileInputName: uid, id: uid }, (accepts ? { fileTypes: accepts } : undefined)), (maxSize ? { sizeLimit: toKilobytes(maxSize) } : undefined)), { sizeLimitErrorMessage: ((_a = fileSchemaDescriptor.validationMessages) === null || _a === void 0 ? void 0 : _a.maxSize) ||
+            defaultErrorMessages.maxFileSizeErrorMessage, maxFiles: props.schema.maxItems, maxFilesErrorMessage: ((_b = props.schema.validationMessages) === null || _b === void 0 ? void 0 : _b.maxItems) || defaultErrorMessages.maxItemsErrorMessage, uploadButtonTitle: fileSchemaDescriptor.title, description: fileSchemaDescriptor.description, disabled: props.disabled, onUploadFile: function (formData) { return uploadFile(formData.get(uid)); }, onFilesChange: onFilesChange, onDeleteFile: function () { return Promise.resolve(); } });
+    return (_jsxs("div", __assign({ className: classNames('form-group', { 'has-error': showError }) }, { children: [_jsx("label", __assign({ className: "d-block control-label", htmlFor: uid }, { children: props.schema.title })), _jsx(UploadInput, __assign({}, uploadInputProps)), _jsx(ControlFeedback, { changed: inputChanged, submitted: props.submitted, errors: props.errors, schema: props.schema, validations: fileListValidationFailures, validationMessages: getValidationMessages(schema, Boolean(props.required), defaultErrorMessages), infoMessage: null, focused: false, blurred: true })] })));
+};
+MultipleFileUploadSchema.defaultProps = {
+    errors: null,
+    required: false
+};
+export default MultipleFileUploadSchema;
+function getSuccessfullyProcessedFiles(allFiles) {
+    return allFiles.filter(function (file) { return !file.error && file.status === 'succeeded'; });
+}
+function convertFileIdsToComponentFileObjects(fileIds) {
+    return filterOutNull(fileIds.map(function (id) { return (isValidId(id) ? { id: id, status: Status.SUCCEEDED } : null); }));
+}
+function isValidId(id) {
+    return isNumber(id) || isString(id);
+}
+function getValidationMessages(schema, required, defaultErrorMessages) {
+    var minItems = schema.minItems, maxItems = schema.maxItems;
+    return __assign(__assign(__assign({}, (required && { required: defaultErrorMessages.requiredMessage })), (minItems && { minItems: defaultErrorMessages.minItemsErrorMessage })), (maxItems && { maxItems: defaultErrorMessages.maxItemsErrorMessage }));
+}

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/MultipleFileUploadSchema.messages.d.ts

@@ -0,0 +1,24 @@
+declare namespace _default {
+    namespace minItemsError {
+        const id: string;
+        const defaultMessage: string;
+        const description: string;
+    }
+    namespace maxItemsError {
+        const id_1: string;
+        export { id_1 as id };
+        const defaultMessage_1: string;
+        export { defaultMessage_1 as defaultMessage };
+        const description_1: string;
+        export { description_1 as description };
+    }
+    namespace maxFileSizeError {
+        const id_2: string;
+        export { id_2 as id };
+        const defaultMessage_2: string;
+        export { defaultMessage_2 as defaultMessage };
+        const description_2: string;
+        export { description_2 as description };
+    }
+}
+export default _default;

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/MultipleFileUploadSchema.messages.js

@@ -0,0 +1,18 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    minItemsError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.minItemsError',
+        defaultMessage: 'Please upload at least {minItems} file(s).',
+        description: 'Customer has uploaded not enough files. To fix: upload more files.'
+    },
+    maxItemsError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.maxItemsError',
+        defaultMessage: 'Please upload {maxItems} or fewer files.',
+        description: 'Customer has uploaded too many files. To fix: upload fewer files.'
+    },
+    maxFileSizeError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.maxFileSizeError',
+        defaultMessage: 'Sorry, that file is too big. Please upload a smaller file.',
+        description: "Customer has uploaded a file that's too big. To fix: upload a smaller file."
+    }
+});

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/index.d.ts

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

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/index.js

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

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/useFormattedDefaultErrorMessages.d.ts

@@ -0,0 +1,9 @@
+export declare function useFormattedDefaultErrorMessages({ maxItems, minItems, }: {
+    maxItems?: number;
+    minItems?: number;
+}): {
+    maxFileSizeErrorMessage: string;
+    maxItemsErrorMessage: string;
+    minItemsErrorMessage: string;
+    requiredMessage: string;
+};

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/useFormattedDefaultErrorMessages.js

@@ -0,0 +1,14 @@
+import { useIntl } from 'react-intl';
+import CommonMessages from '../../../../common/messages';
+import MultiFileUploadMessages from './MultipleFileUploadSchema.messages';
+export function useFormattedDefaultErrorMessages(_a) {
+    var maxItems = _a.maxItems, minItems = _a.minItems;
+    var formatMessage = useIntl().formatMessage;
+    var maxFileSizeError = MultiFileUploadMessages.maxFileSizeError, maxItemsError = MultiFileUploadMessages.maxItemsError, minItemsError = MultiFileUploadMessages.minItemsError;
+    return {
+        maxFileSizeErrorMessage: formatMessage(maxFileSizeError),
+        maxItemsErrorMessage: formatMessage(maxItemsError, { maxItems: maxItems }),
+        minItemsErrorMessage: formatMessage(minItemsError, { minItems: minItems }),
+        requiredMessage: formatMessage(CommonMessages.required)
+    };
+}

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/utils.d.ts

@@ -0,0 +1,6 @@
+import { UploadError, UploadResponse } from '@transferwise/components';
+export declare function createPayload(userUploadedFile: Blob | string | null, isBlobSchema: boolean): Promise<string | Blob | null>;
+export declare function constructUploadResponse(response: {
+    data: string | number;
+}): UploadResponse;
+export declare function constructUploadError(response: unknown): UploadError | undefined;

package/build/jsonSchemaForm/arrayTypeSchema/arrayListSchema/multipleFileUploadSchema/utils.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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { isObject, isString } from '@transferwise/neptune-validation';
+import { toBase64 } from '../../../../common/utils/file-utils';
+import { generateRandomId } from '../../../../common/utils/generate-random-id';
+export function createPayload(userUploadedFile, isBlobSchema) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            if (isBlobSchema) {
+                return [2 /*return*/, userUploadedFile];
+            }
+            else {
+                if (userUploadedFile instanceof Blob) {
+                    return [2 /*return*/, toBase64(userUploadedFile)];
+                }
+                throw new Error('Error creating payload for MultipleFileUploadSchema. Uploaded file is not an instance of Blob.');
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+export function constructUploadResponse(response) {
+    var id = response.data;
+    return __assign({ id: id }, response);
+}
+export function constructUploadError(response) {
+    var isError = response instanceof Error;
+    var hasValidData = isObject(response) && 'data' in response;
+    var isInvalidResponseData = !hasValidData && !isError;
+    if (isInvalidResponseData) {
+        return isString(response) ? response : undefined;
+    }
+    if (isError) {
+        var error = response;
+        return { id: generateRandomId(), message: error.message };
+    }
+    else {
+        return __assign({ message: isString(response.message) ? response.message : '' }, response);
+    }
+}

package/build/jsonSchemaForm/arrayTypeSchema/index.d.ts

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

package/build/jsonSchemaForm/arrayTypeSchema/index.js

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

package/build/jsonSchemaForm/basicTypeSchema/BasicTypeSchema.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { BasicModel, BasicSchema } from '../../dynamic-flow-types';
+import { OnChange } from '../JsonSchemaForm';
+import { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare const BasicTypeSchema: {
+    (props: BasicTypeSchemaProps): JSX.Element | null;
+    defaultProps: {
+        required: boolean;
+        disabled: boolean;
+        onBlur: null;
+    };
+};
+export type BasicTypeSchemaProps = Omit<GenericSchemaProps, 'schema' | 'model' | 'onChange' | 'errors' | 'onPersistAsync'> & {
+    schema: BasicSchema;
+    model: BasicModel | null;
+    errors: string | null;
+    required?: boolean;
+    infoMessage: string | null;
+    onBlur?: () => void;
+    onChange: OnChange;
+};
+export default BasicTypeSchema;

package/build/jsonSchemaForm/basicTypeSchema/BasicTypeSchema.js

@@ -0,0 +1,105 @@
+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 { isNull, isUndefined } from '@transferwise/neptune-validation';
+import classNames from 'classnames';
+import { useEffect, useMemo, useState } from 'react';
+import { generateRandomId } from '../../common/utils/generate-random-id';
+import { getValidBasicModelOrNull } from '../../common/validation/valid-model';
+import { getValidationFailures } from '../../common/validation/validation-failures';
+import DynamicAlert from '../../layout/alert';
+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) {
+        setChanged(true);
+        setModelAndBroadcast(sanitiseModel(newModel), 'user');
+    };
+    var getValidationKeys = function (newModel) {
+        return getValidationFailures(newModel, props.schema, props.required);
+    }; // TODO: LOW avoid type assertion
+    var setModelAndBroadcast = function (newModel, type) {
+        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
+            });
+        }
+    };
+    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; return setModel((_a = props.model) !== null && _a !== void 0 ? _a : null); }, [props.model]);
+    var formGroupClasses = {
+        'form-group': true,
+        'has-error': ((props.submitted || !changed) && !!props.errors) ||
+            ((props.submitted || (changed && blurred)) && !!validations.length),
+        'has-info': (focused && !!props.schema.description) || !!props.infoMessage
+    };
+    var showLabel = props.schema.format !== 'file' && props.schema.type !== 'boolean';
+    var schemaHelp = props.schema.help;
+    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" }, { 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 }), _jsx(ControlFeedback, { 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/jsonSchemaForm/basicTypeSchema/index.d.ts

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

package/build/jsonSchemaForm/basicTypeSchema/index.js

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