@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/jsonSchemaForm/controlFeedback/ControlFeedback.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import { Schema } from '../../dynamic-flow-types';
+declare const ControlFeedback: {
+    (props: ControlFeedbackProps): JSX.Element;
+    defaultProps: {
+        errors: string;
+        validations: never[];
+        validationMessages: {};
+        validationAsyncSuccessMessage: null;
+    };
+};
+type ValidationMessages = {
+    minimum?: string;
+    maximum?: string;
+    minLength?: string;
+    maxLength?: string;
+    pattern?: string;
+    required?: string;
+};
+export type ControlFeedbackProps = {
+    changed: boolean;
+    blurred: boolean;
+    focused: boolean;
+    submitted: boolean;
+    errors?: string | null;
+    validations?: string[];
+    validationMessages?: ValidationMessages;
+    schema: Schema;
+    infoMessage: string | null;
+};
+export default ControlFeedback;

package/build/jsonSchemaForm/controlFeedback/ControlFeedback.js

@@ -0,0 +1,79 @@
+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 controlFeedbackMessages from './ControlFeedback.messages';
+var ControlFeedback = function (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) && !!props.errors;
+    var isValidationVisible = !isErrorVisible &&
+        (props.submitted || (props.changed && props.blurred)) &&
+        !!((_a = props.validations) === null || _a === void 0 ? void 0 : _a.length);
+    var isDescriptionVisible = props.focused && props.schema.description && !isValidationVisible;
+    var hasInfoMessage = !!props.infoMessage;
+    return (_jsxs("div", { 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
+        }),
+        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/jsonSchemaForm/controlFeedback/ControlFeedback.messages.d.ts

@@ -0,0 +1,53 @@
+declare const _default: {
+    type: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    minimum: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    maximum: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    minLength: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    maxLength: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    minimumDate: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    maximumDate: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    pattern: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    patternDate: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    required: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,53 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    type: {
+        id: 'dynamicFlows.ControlFeedback.type',
+        defaultMessage: 'Incorrect type',
+        description: ''
+    },
+    minimum: {
+        id: 'dynamicFlows.ControlFeedback.minimum',
+        defaultMessage: "Please enter a number that's {minimum} or more.",
+        description: ''
+    },
+    maximum: {
+        id: 'dynamicFlows.ControlFeedback.maximum',
+        defaultMessage: "Please enter a number that's {maximum} or less.",
+        description: ''
+    },
+    minLength: {
+        id: 'dynamicFlows.ControlFeedback.minLength',
+        defaultMessage: 'Please enter at least {minLength} characters.',
+        description: ''
+    },
+    maxLength: {
+        id: 'dynamicFlows.ControlFeedback.maxLength',
+        defaultMessage: 'Please enter {maxLength} or fewer characters.',
+        description: ''
+    },
+    minimumDate: {
+        id: 'dynamicFlows.ControlFeedback.minimumDate',
+        defaultMessage: "Please enter a date that's on or after {minimum}.",
+        description: ''
+    },
+    maximumDate: {
+        id: 'dynamicFlows.ControlFeedback.maximumDate',
+        defaultMessage: "Please enter a date that's on or before {maximum}.",
+        description: ''
+    },
+    pattern: {
+        id: 'dynamicFlows.ControlFeedback.pattern',
+        defaultMessage: 'Please enter this in the correct format.',
+        description: ''
+    },
+    patternDate: {
+        id: 'dynamicFlows.ControlFeedback.patternDate',
+        defaultMessage: 'Please enter a date in the corrrect format.',
+        description: ''
+    },
+    required: {
+        id: 'dynamicFlows.ControlFeedback.required',
+        defaultMessage: 'Please fill out this field.',
+        description: ''
+    }
+});

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

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

package/build/jsonSchemaForm/controlFeedback/index.js

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

package/build/jsonSchemaForm/genericSchema/GenericSchema.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { FormErrors, Model, Schema } from '../../dynamic-flow-types';
+import { OnPersistAsync } from '../../schema';
+import { OnChange } from '../JsonSchemaForm';
+declare const GenericSchemaForm: (props: GenericSchemaFormProps) => JSX.Element;
+export type GenericSchemaProps = {
+    schema: Schema;
+    model: Model;
+    errors: FormErrors;
+    submitted: boolean;
+    disabled?: boolean;
+    onChange: OnChange;
+    onPersistAsync: OnPersistAsync;
+};
+type GenericSchemaFormProps = GenericSchemaProps & {
+    hideTitle?: boolean;
+    required?: boolean;
+};
+export default GenericSchemaForm;

package/build/jsonSchemaForm/genericSchema/GenericSchema.js

@@ -0,0 +1,122 @@
+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 { useLogger } from '../../common/logging';
+import { getSchemaType } from '../../common/schemaTypes/schemaTypes';
+import { isNullableBasicModel, isPersistAsyncSchema, isValidationAsyncSchema, isBasicSchema, isObjectSchema, isNullableObjectModel, isArraySchema, isNullableArrayModel, isOneOfSchema, isNullableStringModel, isBasicError, isObjectModel, } from '../../dynamic-flow-types';
+import { isAllOfSchema, isOneOfObjectSchema } from '../../dynamic-flow-types/Schema';
+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';
+var GenericSchemaForm = function (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();
+    var logInvalidSchemaWarning = function () {
+        return log.error('Invalid schema or model', "Schema of type ".concat(type || 'undefined', " requested, but schema did not pass validation."));
+    };
+    switch (type) {
+        case 'readOnly':
+            return _jsx(ReadOnlySchema, __assign({}, schemaProps));
+        case 'persistAsync':
+            if (isPersistAsyncSchema(schema) && isNullableStringModel(model) && isBasicError(errors)) {
+                var filteredProps = __assign(__assign({}, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(PersistAsyncSchema, __assign({}, filteredProps));
+            }
+            else {
+                // TODO: MC-3224 Remove this once people have had a chance to fix errors
+                logInvalidSchemaWarning();
+                return _jsx(PersistAsyncSchema, __assign({}, props));
+            }
+        case 'validationAsync':
+            if (isValidationAsyncSchema(schema) && isNullableBasicModel(model) && isBasicError(errors)) {
+                var filteredProps = __assign(__assign({}, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(ValidationAsyncSchema, __assign({}, filteredProps));
+            }
+            else {
+                // TODO: MC-3224
+                logInvalidSchemaWarning();
+                return _jsx(ValidationAsyncSchema, __assign({}, props));
+            }
+        case 'basic': {
+            if (isBasicSchema(schema) && isNullableBasicModel(model) && isBasicError(errors)) {
+                var filteredProps = __assign(__assign({ infoMessage: null }, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(BasicTypeSchema, __assign({}, filteredProps));
+            }
+            else {
+                var filteredProps = __assign(__assign({ infoMessage: null }, schemaProps), { schema: schema, model: model, errors: errors });
+                // TODO: MC-3224
+                logInvalidSchemaWarning();
+                return _jsx(BasicTypeSchema, __assign({}, filteredProps));
+            }
+        }
+        case 'object':
+            if (isObjectSchema(schema) && isNullableObjectModel(model)) {
+                var filteredProps = __assign(__assign({}, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(ObjectSchema, __assign({}, filteredProps), JSON.stringify(schema));
+            }
+            else {
+                // TODO: MC-3224
+                logInvalidSchemaWarning();
+                return _jsx(ObjectSchema, __assign({}, props));
+            }
+        case 'array':
+            if (isArraySchema(schema) && isNullableArrayModel(model) && isBasicError(errors)) {
+                var filteredProps = __assign(__assign({}, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(ArraySchema, __assign({}, filteredProps));
+            }
+            else {
+                // TODO: MC-3224
+                logInvalidSchemaWarning();
+                return _jsx(ArraySchema, __assign({}, props));
+            }
+        case 'promotedOneOf':
+            if (isOneOfObjectSchema(schema) && isNullableObjectModel(model)) {
+                var filteredProps = __assign(__assign({}, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(PromotedOneOfSchema, __assign({}, filteredProps));
+            }
+            else {
+                // TODO: MC-3224
+                logInvalidSchemaWarning();
+                return _jsx(PromotedOneOfSchema, __assign({}, props));
+            }
+        case 'oneOf':
+            if (isOneOfSchema(schema)) {
+                var filteredProps = __assign(__assign({}, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(OneOfSchema, __assign({}, filteredProps));
+            }
+            else {
+                // TODO: MC-3224
+                logInvalidSchemaWarning();
+                return _jsx(OneOfSchema, __assign({}, props));
+            }
+        case 'allOf':
+            if (isAllOfSchema(schema) && isObjectModel(model)) {
+                var filteredProps = __assign(__assign({}, schemaProps), { schema: schema, model: model, errors: errors });
+                return _jsx(AllOfSchema, __assign({}, filteredProps));
+            }
+            else {
+                // TODO: MC-3224
+                logInvalidSchemaWarning();
+                return _jsx(AllOfSchema, __assign({}, props));
+            }
+    }
+    return _jsx(_Fragment, {});
+};
+export default GenericSchemaForm;

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

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

package/build/jsonSchemaForm/genericSchema/index.js

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

package/build/jsonSchemaForm/help/Help.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+type Props = {
+    help: {
+        markdown: string;
+    };
+};
+declare const Help: (props: Props) => JSX.Element;
+export default Help;

package/build/jsonSchemaForm/help/Help.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Markdown, Info } from '@transferwise/components';
+import { useIntl } from 'react-intl';
+import messages from './Help.messages';
+var Help = function (props) {
+    var intl = useIntl();
+    return (_jsx(Info, { className: "m-l-1", content: _jsx(Markdown, { children: props.help.markdown }), presentation: "POPOVER", size: "sm", "aria-label": intl.formatMessage(messages.helpAria) }));
+};
+export default Help;

package/build/jsonSchemaForm/help/Help.messages.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    namespace helpAria {
+        const id: string;
+        const defaultMessage: string;
+        const description: string;
+    }
+}
+export default _default;

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

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    helpAria: {
+        id: 'dynamicFlows.Help.ariaLabel',
+        defaultMessage: 'Click here for more info.',
+        description: 'Aria label for help.'
+    }
+});

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

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

package/build/jsonSchemaForm/help/index.js

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

package/build/jsonSchemaForm/index.d.ts

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

package/build/jsonSchemaForm/index.js

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

package/build/jsonSchemaForm/objectSchema/ObjectSchema.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { ObjectModel, ObjectSchema as ObjectSchemaType } from '../../dynamic-flow-types';
+import { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare const ObjectSchema: {
+    (props: ObjectSchemaProps): JSX.Element;
+    defaultProps: {
+        hideTitle: boolean;
+        disabled: boolean;
+    };
+};
+export type ObjectSchemaProps = GenericSchemaProps & {
+    schema: ObjectSchemaType;
+    model: ObjectModel | null;
+    hideTitle?: boolean;
+};
+export default ObjectSchema;

package/build/jsonSchemaForm/objectSchema/ObjectSchema.js

@@ -0,0 +1,78 @@
+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 { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import classNames from 'classnames';
+import isEqual from 'lodash.isequal';
+import { useState, useEffect } from 'react';
+import { getValidObjectModelParts } from '../../common/validation/valid-model';
+import DynamicAlert from '../../layout/alert';
+import GenericSchema from '../genericSchema';
+var getSchemaColumnClasses = function (width) {
+    return {
+        'col-xs-12': true,
+        'col-sm-6': width === 'md',
+        'col-sm-4': width === 'sm'
+    };
+};
+var ObjectSchema = function (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
+            // eslint-disable-next-line fp/no-mutation
+            model[propertyName] = onChangeProps.model;
+        }
+        else {
+            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("fieldset", { children: [props.schema.title && !props.hideTitle && _jsxs("legend", { children: [" ", props.schema.title, " "] }), props.schema.description && !props.hideTitle && _jsxs("p", { children: [" ", props.schema.description, " "] }), props.schema.alert && _jsx(DynamicAlert, { component: props.schema.alert }), _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 && 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/jsonSchemaForm/objectSchema/index.d.ts

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

package/build/jsonSchemaForm/objectSchema/index.js

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

package/build/jsonSchemaForm/oneOfSchema/OneOfSchema.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { OneOfSchema as OneOfSchemaType } from '../../dynamic-flow-types';
+import { GenericSchemaProps } from '../genericSchema/GenericSchema';
+declare const OneOfSchema: {
+    (props: OneOfSchemaProps): JSX.Element | null;
+    defaultProps: {
+        required: boolean;
+        disabled: boolean;
+    };
+};
+export type OneOfSchemaProps = Omit<GenericSchemaProps, 'schema'> & {
+    schema: OneOfSchemaType;
+    required?: boolean;
+};
+export default OneOfSchema;