@wise/dynamic-flow-client 3.11.2 → 3.11.4-experiment-node20-aa45bc2

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

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

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

@@ -0,0 +1,233 @@
+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 { mount } from 'enzyme';
+import FormControl from '../../formControl/FormControl';
+import { TestContextProviders } from '../../test-utils';
+import ControlFeedback from '../controlFeedback';
+import BasicTypeSchema from '.';
+var mountOptions = {
+    wrappingComponent: TestContextProviders,
+};
+describe('Given a component for rendering basic type schemas', function () {
+    describe('when submitted', function () {
+        it('displays validation and server errors', function () {
+            var props = {
+                schema: {
+                    type: 'string',
+                    minLength: 2,
+                    title: 'Complete all sections',
+                    default: '',
+                },
+                model: '',
+                errors: undefined,
+                required: true,
+                onChange: jest.fn(),
+                submitted: false,
+            };
+            var component = mount(_jsx(BasicTypeSchema, __assign({}, props)), mountOptions);
+            var formControl = component.find(FormControl);
+            var getControlFeedback = function () { return component.find(ControlFeedback); };
+            // expect no errors displayed
+            expect(getControlFeedback().text()).toBe('');
+            // submit form
+            component.setProps({ submitted: true });
+            // expect the validation error to be displayed
+            expect(getControlFeedback().text()).toMatch(/Please fill out this field./i);
+            // type in some text
+            formControl.simulate('change', { target: { value: 'Some text' } });
+            // submit form again
+            component.setProps({ submitted: true });
+            // simulate server response
+            component.setProps({ errors: 'The server call retuned an error' });
+            // expect the server error to be displayed
+            expect(getControlFeedback().text()).toBe('The server call retuned an error');
+            // type in some more text
+            formControl.simulate('change', 'Some more text');
+            component.setProps({ submitted: false });
+            // expect the error to be hidden because model changed
+            expect(getControlFeedback().text()).toBe('');
+        });
+    });
+});
+describe('Given a component for rendering a number schema', function () {
+    var props = {
+        errors: undefined,
+        required: true,
+        onChange: jest.fn(),
+        submitted: true,
+    };
+    describe('when a number schema has no default validation messages', function () {
+        var schema = {
+            type: 'number',
+            minimum: 2,
+            maximum: 10,
+            title: 'Enter a number between 2 and 10',
+            default: '',
+        };
+        describe('when submitted with value too low', function () {
+            it('displays the default validation error', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: 1 })), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toMatch(/Please enter a number that's 2 or more./i);
+            });
+        });
+        describe('when submitted with value too high', function () {
+            it('displays the default validation error', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: 999 })), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toMatch(/Please enter a number that's 10 or less./i);
+            });
+        });
+    });
+    describe('when the string schema has no default validation messages', function () {
+        var schema = {
+            type: 'string',
+            minLength: 2,
+            maxLength: 10,
+            title: 'Enter a string of between 2 and 10 characters',
+            default: '',
+        };
+        describe('when submitted with value too short', function () {
+            it('displays the default validation error', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: "a" })), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toMatch(/Please enter at least 2 characters./i);
+            });
+        });
+        describe('when submitted with value too long', function () {
+            it('displays the default validation error', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: "abcdefghijkl" })), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toMatch(/Please enter 10 or fewer characters./i);
+            });
+        });
+    });
+    describe('given a required boolean schema', function () {
+        describe('when the model is null and there is a default', function () {
+            var schema = {
+                type: 'boolean',
+                title: 'Yes or no?',
+                default: false,
+            };
+            it('does not display a validation error', function () {
+                var onChange = jest.fn();
+                var component = mount(_jsx(BasicTypeSchema, { submitted: true, required: true, schema: schema, model: null, onChange: onChange }), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toBe('');
+            });
+            it('calls onChange with the default value AND type: "init"', function () {
+                var onChange = jest.fn();
+                mount(_jsx(BasicTypeSchema, { submitted: true, required: true, schema: schema, model: null, onChange: onChange }), mountOptions);
+                expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+                    model: schema.default,
+                    triggerSchema: schema,
+                    triggerModel: schema.default,
+                    lastTriggerModel: null,
+                    type: 'init',
+                }));
+            });
+        });
+        describe("when the model is null BUT there's NO default", function () {
+            var schema = {
+                type: 'boolean',
+                title: 'Yes or no?',
+            };
+            describe("it uses the implicit default value of \"false\" and...", function () {
+                it('does not display a validation error', function () {
+                    var onChange = jest.fn();
+                    var component = mount(_jsx(BasicTypeSchema, { submitted: true, required: true, schema: schema, model: null, onChange: onChange }), mountOptions);
+                    var getControlFeedback = function () { return component.find(ControlFeedback); };
+                    expect(getControlFeedback().text()).toBe('');
+                });
+                it('calls onChange with the new value', function () {
+                    var onChange = jest.fn();
+                    mount(_jsx(BasicTypeSchema, { submitted: true, required: true, schema: schema, model: null, onChange: onChange }), mountOptions);
+                    expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+                        model: false,
+                        triggerSchema: schema,
+                        triggerModel: false,
+                        lastTriggerModel: null,
+                    }));
+                });
+            });
+        });
+        describe('when the model is false and the default is true', function () {
+            var schema = {
+                type: 'boolean',
+                title: 'Yes or no?',
+                default: true,
+            };
+            it('does not use the default value', function () {
+                var onChange = jest.fn();
+                mount(_jsx(BasicTypeSchema, { submitted: true, required: true, schema: schema, model: false, onChange: onChange }), mountOptions);
+                expect(onChange).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('when a string (date) schema has no default validation messages', function () {
+        describe('when schema does not contain minimum nor maximum values', function () {
+            it('does not display a validation error', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: { type: 'string', format: 'date', title: 'Enter any date', default: '' }, model: "1999-12-31" })), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toMatch('');
+            });
+        });
+        var schema = {
+            type: 'string',
+            format: 'date',
+            minimum: '2000-01-01',
+            maximum: '2010-12-31',
+            title: 'Enter a date between 2000 and 2010',
+            default: '',
+        };
+        describe('when submitted with value too low', function () {
+            it('displays the default validation error', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: "1999-12-31" })), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toMatch(/Please enter a date that's on or after 1 January 2000./i);
+            });
+        });
+        describe('when submitted with value too high', function () {
+            it('displays the default validation error', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: "2011-01-01" })), mountOptions);
+                var getControlFeedback = function () { return component.find(ControlFeedback); };
+                expect(getControlFeedback().text()).toMatch(/Please enter a date that's on or before 31 December 2010./i);
+            });
+        });
+    });
+    describe('when the schema contains default validation messages', function () {
+        var schema = {
+            type: 'number',
+            minimum: 2,
+            maximum: 10,
+            title: 'Enter a number between 2 and 10',
+            default: '',
+            validationMessages: {
+                minimum: 'The number is too low',
+                maximum: 'The number is too high',
+            },
+        };
+        describe('when submitted with value too low', function () {
+            it('displays the validation error specified in the schema', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: 1 })), mountOptions);
+                expect(component.find(ControlFeedback).text()).toMatch(/The number is too low/i);
+            });
+        });
+        describe('when submitted with value too high', function () {
+            it('displays the validation error specified in the schema', function () {
+                var component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: schema, model: 999 })), mountOptions);
+                expect(component.find(ControlFeedback).text()).toMatch(/The number is too high/i);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,100 @@
+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", { className: classNames(formGroupClasses), children: [showLabel && (_jsxs("div", { className: "d-inline-block m-b-1", children: [_jsx("label", { 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/BasicTypeSchema.spec.js

@@ -0,0 +1,291 @@
+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 { Provider } from '@transferwise/components';
+import { shallow, mount } from 'enzyme';
+import * as loggingModule from '../../common/contexts/logContext/LogContext';
+import { DynamicAlert } from '../../layout';
+import { getI18n, mockUseLogger } from '../../test-utils';
+import ControlFeedback from '../controlFeedback';
+import Help from '../help';
+import SchemaFormControl from '../schemaFormControl';
+import BasicTypeSchema from '.';
+jest.mock('../../common/utils/id-utils', function () { return ({
+    generateRandomId: function () { return 'DUMMY_GENERATED_UNIQUE_ID'; },
+}); });
+jest.spyOn(loggingModule, 'useLogger').mockImplementation(mockUseLogger);
+describe('Given a component for rendering basic type schemas', function () {
+    var component;
+    var props;
+    var onChange;
+    var formControl;
+    var feedbackComponent;
+    var schema = {
+        type: 'string',
+        minLength: 2,
+        title: 'Complete all sections',
+        default: 'bar',
+    };
+    var model;
+    var errors = 'error';
+    var required = true;
+    var submitted = false;
+    var mountOptions = {
+        wrappingComponent: Provider,
+        wrappingComponentProps: { i18n: getI18n() },
+    };
+    beforeEach(function () {
+        onChange = jest.fn();
+    });
+    describe('id prop', function () {
+        props = { schema: schema, model: model, errors: errors, required: required, onChange: onChange, submitted: submitted };
+        it('should be the $id in schema', function () {
+            component = shallow(_jsx(BasicTypeSchema, __assign({}, props, { schema: __assign(__assign({}, schema), { $id: 'DUMMY_ID' }) })));
+            expect(component.find(SchemaFormControl).prop('id')).toBe('DUMMY_ID');
+        });
+        it('should be random number if $id is not present in schema', function () {
+            component = shallow(_jsx(BasicTypeSchema, __assign({}, props)));
+            expect(component.find(SchemaFormControl).prop('id')).toBe('DUMMY_GENERATED_UNIQUE_ID');
+        });
+    });
+    describe('when initialised with a model', function () {
+        beforeEach(function () {
+            model = 'foo';
+            props = { schema: schema, model: model, errors: errors, required: required, onChange: onChange, submitted: submitted };
+            component = shallow(_jsx(BasicTypeSchema, __assign({}, props)));
+            formControl = component.find(SchemaFormControl);
+            feedbackComponent = component.find(ControlFeedback);
+        });
+        it('should display one SchemaFormControl', function () {
+            expect(formControl).toHaveLength(1);
+        });
+        it('should pass the model to the value of the SchemaFormControl', function () {
+            expect(formControl.prop('value')).toStrictEqual(model);
+        });
+        it('should pass the errors to the ControlFeedback', function () {
+            expect(feedbackComponent.prop('errors')).toStrictEqual(errors);
+        });
+        it('should initially tell the ControlFeedback it is unchanged', function () {
+            expect(feedbackComponent.prop('changed')).toBe(false);
+        });
+        it('should initially tell the ControlFeedback it is unblurred', function () {
+            expect(feedbackComponent.prop('blurred')).toBe(false);
+        });
+        it('should pass the schema to ControlFeedback', function () {
+            expect(feedbackComponent.prop('schema')).toBe(schema);
+        });
+        describe('when alert exists', function () {
+            it('should render the alert', function () {
+                var alert = {
+                    context: 'info',
+                    markdown: 'some text',
+                };
+                var schemaWithAlert = __assign(__assign({}, schema), { alert: alert });
+                component = shallow(_jsx(BasicTypeSchema, __assign({}, props, { schema: schemaWithAlert })));
+                var alertComponent = component.find(DynamicAlert);
+                expect(alertComponent).toHaveLength(1);
+                expect(alertComponent.prop('component').context).toBe('info');
+                expect(alertComponent.prop('component').markdown).toBe('some text');
+            });
+        });
+        describe('when alert does not exist', function () {
+            it('should not render alert', function () {
+                component = shallow(_jsx(BasicTypeSchema, __assign({}, props)));
+                var alertComponent = component.find(DynamicAlert);
+                expect(alertComponent).toHaveLength(0);
+            });
+        });
+        describe('when help exists', function () {
+            it('should render help popover', function () {
+                var help = {
+                    markdown: 'some help',
+                };
+                var schemaWithHelp = __assign(__assign({}, schema), { help: help });
+                component = shallow(_jsx(BasicTypeSchema, __assign({}, props, { schema: schemaWithHelp })));
+                var helpPopover = component.find(Help);
+                expect(helpPopover).toHaveLength(1);
+            });
+        });
+        describe('when help does not exist', function () {
+            it('should not render help popover', function () {
+                component = shallow(_jsx(BasicTypeSchema, __assign({}, props)));
+                var helpPopover = component.find(Help);
+                expect(helpPopover).toHaveLength(0);
+            });
+        });
+        describe('when control is focused', function () {
+            beforeEach(function () {
+                formControl.simulate('focus');
+                feedbackComponent = component.find(ControlFeedback);
+            });
+            it('should tell the ControlFeedback it has focus', function () {
+                expect(feedbackComponent.prop('focused')).toBe(true);
+            });
+            it('should not tell the ControlFeedback it has been blurred', function () {
+                expect(feedbackComponent.prop('blurred')).toBe(false);
+            });
+            describe('and then blurred', function () {
+                beforeEach(function () {
+                    formControl.simulate('blur');
+                    feedbackComponent = component.find(ControlFeedback);
+                });
+                it('should tell the ControlFeedback it has been blurred', function () {
+                    expect(feedbackComponent.prop('blurred')).toBe(true);
+                });
+                it('should not tell the ControlFeedback it has focus', function () {
+                    expect(feedbackComponent.prop('focused')).toBe(false);
+                });
+            });
+        });
+        describe('when control triggers onChange with a valid value', function () {
+            beforeEach(function () {
+                formControl.simulate('change', 'barbar');
+                feedbackComponent = component.find(ControlFeedback);
+            });
+            it('should trigger the components onChange with the new value', function () {
+                expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+                    model: 'barbar',
+                    triggerSchema: schema,
+                    triggerModel: 'barbar',
+                    lastTriggerModel: 'foo',
+                }));
+            });
+            it('should tell the ControlFeedback it has been changed', function () {
+                expect(feedbackComponent.prop('changed')).toBe(true);
+            });
+            it('should broadcast null value for optional field when valid input changes to empty string', function () {
+                model = 'foo';
+                var isRequired = false;
+                props = { schema: schema, model: model, errors: errors, isRequired: isRequired, onChange: onChange, submitted: submitted };
+                component = shallow(_jsx(BasicTypeSchema, __assign({}, props)));
+                formControl = component.find(SchemaFormControl);
+                feedbackComponent = component.find(ControlFeedback);
+                // valid non null value
+                formControl.simulate('change', 'barbar');
+                expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ model: 'barbar' }));
+                // empty value but is still valid
+                formControl.simulate('change', '');
+                expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ model: null }));
+                expect(feedbackComponent.prop('validations')).toHaveLength(0);
+            });
+        });
+        describe('when control triggers onChange with an invalid value', function () {
+            beforeEach(function () {
+                formControl.simulate('change', 'f');
+                feedbackComponent = component.find(ControlFeedback);
+                formControl = component.find(SchemaFormControl);
+            });
+            it('should trigger the components onChange with the invalid value', function () {
+                expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+                    model: 'f',
+                    triggerSchema: schema,
+                    triggerModel: 'f',
+                    lastTriggerModel: 'foo',
+                }));
+            });
+            it('should pass the correct validation to ControlFeedback component', function () {
+                expect(feedbackComponent.prop('validations')).toStrictEqual(['minLength']);
+            });
+            it('should not reset the form control to the default', function () {
+                expect(formControl.prop('value')).not.toStrictEqual(schema.default);
+            });
+            it('should pass the new value to the form control', function () {
+                expect(formControl.prop('value')).toBe('f');
+            });
+        });
+        describe('when control triggers onChange with a value of invalid type', function () {
+            beforeEach(function () {
+                var integerSchema = { type: 'integer' };
+                model = 123;
+                props = { schema: integerSchema, model: model, errors: errors, required: required, onChange: onChange, submitted: submitted };
+                component = shallow(_jsx(BasicTypeSchema, __assign({}, props)));
+                formControl = component.find(SchemaFormControl);
+                feedbackComponent = component.find(ControlFeedback);
+                formControl.simulate('change', 123.45); // not an integer, but a float
+                formControl = component.find(SchemaFormControl);
+                feedbackComponent = component.find(ControlFeedback);
+            });
+            it('should pass the correct validation to ControlFeedback component', function () {
+                expect(feedbackComponent.prop('validations')).toStrictEqual(['type']);
+            });
+            it('should pass the new value to the form control', function () {
+                expect(formControl.prop('value')).toBe(123.45);
+            });
+        });
+        describe('when submitted changes to true without a change to the model', function () {
+            beforeEach(function () {
+                var localSchema = __assign(__assign({}, schema), { default: undefined });
+                component = mount(_jsx(BasicTypeSchema, __assign({}, props, { schema: localSchema, required: true, model: null })), mountOptions);
+            });
+            it('should update validations using the current model', function () {
+                component.setProps({ submitted: true });
+                feedbackComponent = component.find(ControlFeedback);
+                expect(component.find('div.has-error')).toHaveLength(1);
+                expect(feedbackComponent.prop('validations')).toStrictEqual(['required']);
+            });
+        });
+        describe('when control changes to a value that resolves to false', function () {
+            beforeEach(function () {
+                formControl.simulate('change', '');
+                feedbackComponent = component.find(ControlFeedback);
+                formControl = component.find(SchemaFormControl);
+            });
+            it('should not reset the form control to the default', function () {
+                expect(formControl.prop('value')).not.toStrictEqual(schema.default);
+            });
+            it('should pass null value to the form control', function () {
+                expect(formControl.prop('value')).toBeNull();
+            });
+        });
+    });
+    describe('when initialised without a model and there is a default', function () {
+        beforeEach(function () {
+            model = null;
+            props = { schema: schema, model: model, errors: errors, required: required, onChange: onChange, submitted: submitted };
+            // useEffect is not currently called when using shallow
+            // https://github.com/airbnb/enzyme/issues/2086
+            component = mount(_jsx(BasicTypeSchema, __assign({}, props)), mountOptions);
+        });
+        it('should call the onChange handler with the default value AND type: "init"', function () {
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+                model: schema.default,
+                triggerSchema: schema,
+                triggerModel: schema.default,
+                lastTriggerModel: null,
+                type: 'init',
+            }));
+        });
+    });
+    describe('when initialised without a model and schema is a const AND type: "init"', function () {
+        var constSchema = { const: 'abcd' };
+        beforeEach(function () {
+            model = null;
+            props = { schema: constSchema, model: model, errors: errors, required: required, onChange: onChange, submitted: submitted };
+            // useEffect is not currently called when using shallow
+            // https://github.com/airbnb/enzyme/issues/2086
+            component = mount(_jsx(BasicTypeSchema, __assign({}, props)), mountOptions);
+        });
+        it('should call the onChange handler with the const', function () {
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+                model: constSchema.const,
+                triggerSchema: constSchema,
+                triggerModel: constSchema.const,
+                lastTriggerModel: null,
+                type: 'init',
+            }));
+        });
+        it('should not show any label or control', function () {
+            expect(component.find('label')).toHaveLength(0);
+            expect(component.find(SchemaFormControl)).toHaveLength(0);
+        });
+    });
+});

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

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