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

package/build/legacy/jsonSchemaForm/promotedOneOfSchema/PromotedOneOfSchema.spec.js

@@ -0,0 +1,420 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RadioGroup } from '@transferwise/components';
+import { shallow } from 'enzyme';
+import * as loggingModule from '../../common/contexts/logContext/LogContext';
+import { DynamicAlert } from '../../layout';
+import { mockUseLogger } from '../../test-utils';
+import GenericSchema from '../genericSchema';
+import ObjectSchema from '../objectSchema';
+import OneOfSchema from '../oneOfSchema';
+import PromotedOneOfSchema from './PromotedOneOfSchema';
+import PromotedOneOfControl from './promotedOneOfControl/PromotedOneOfControl';
+import PromotedOneOfRadioControl from './promotedOneOfControl/PromotedOneOfRadioControl';
+jest.spyOn(loggingModule, 'useLogger').mockImplementation(mockUseLogger);
+describe('Given a PromotedOneOfSchema component', function () {
+    var component;
+    var onChange;
+    var onPersistAsync;
+    var props;
+    var schema;
+    var model;
+    var errors = {};
+    var submitted = false;
+    var promotedSchema = {
+        type: 'object',
+        title: 'Option A',
+        properties: {
+            a: {
+                type: 'number',
+            },
+        },
+        required: ['a'],
+        promoted: true,
+    };
+    var oneOtherOption = [
+        {
+            type: 'object',
+            title: 'Option B',
+            properties: {
+                b: {
+                    type: 'number',
+                },
+            },
+            required: ['b'],
+        },
+    ];
+    var twoOtherOptions = [
+        {
+            type: 'object',
+            title: 'Option B',
+            properties: {
+                b: {
+                    type: 'number',
+                },
+            },
+            required: ['b'],
+        },
+        {
+            type: 'object',
+            title: 'Option C',
+            properties: {
+                c: {
+                    type: 'number',
+                },
+            },
+            required: ['c'],
+        },
+    ];
+    var promotion = {
+        other: {
+            title: 'Other title',
+            icon: {
+                name: 'bank',
+                type: 'icon',
+            },
+            heading: {
+                text: 'Other group heading',
+                type: 'heading',
+            },
+        },
+    };
+    beforeEach(function () {
+        onChange = jest.fn();
+        onPersistAsync = jest.fn();
+    });
+    describe('when initialised with a schema', function () {
+        beforeEach(function () {
+            model = {};
+            schema = {
+                $id: 'DUMMY_ID',
+                title: 'Choose schema',
+                oneOf: __spreadArray([promotedSchema], twoOtherOptions, true),
+                alert: {
+                    context: 'success',
+                    markdown: 'some alert',
+                    type: 'alert',
+                },
+                promotion: promotion,
+                control: 'tab',
+            };
+            props = {
+                schema: schema,
+                model: model,
+                errors: errors,
+                onChange: onChange,
+                submitted: submitted,
+                onPersistAsync: onPersistAsync,
+            };
+            component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+        });
+        it('should render PromotedOneOfControl', function () {
+            expect(component.find(PromotedOneOfControl)).toHaveLength(1);
+        });
+        it('should default to the promoted option', function () {
+            var control = component.find(PromotedOneOfControl);
+            expect(control.props().selection).toBe('promoted');
+        });
+        it('should pass $id as id prop to the SchemaFormControl', function () {
+            var control = component.find(PromotedOneOfControl);
+            expect(control.props().id).toBe('DUMMY_ID');
+        });
+        describe('when a specific default has been specified', function () {
+            it('should default to the specified option', function () {
+                var promotionWithDefault = __assign(__assign({}, promotion), { default: 'other' });
+                schema = __assign(__assign({}, schema), { promotion: promotionWithDefault });
+                props = __assign(__assign({}, props), { schema: schema });
+                component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                var control = component.find(PromotedOneOfControl);
+                expect(control.props().selection).toBe('other');
+            });
+        });
+        describe('when the model matches a particular schema', function () {
+            describe('when the matched schema is promoted', function () {
+                it('should select the matched schema ignoring default specification', function () {
+                    var promotionWithDefault = __assign(__assign({}, promotion), { default: 'other' });
+                    schema = __assign(__assign({}, schema), { promotion: promotionWithDefault });
+                    model = { a: 123 };
+                    props = __assign(__assign({}, props), { model: model, schema: schema });
+                    component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                    var control = component.find(PromotedOneOfControl);
+                    expect(control.props().selection).toBe('promoted');
+                });
+            });
+            describe('when the matched schema is other', function () {
+                it('should select the matched schema ignoring default specification', function () {
+                    var promotionWithDefault = __assign(__assign({}, promotion), { default: 'promoted' });
+                    schema = __assign(__assign({}, schema), { promotion: promotionWithDefault });
+                    model = { b: 123 };
+                    props = __assign(__assign({}, props), { model: model, schema: schema });
+                    component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                    var control = component.find(PromotedOneOfControl);
+                    expect(control.props().selection).toBe('other');
+                });
+            });
+        });
+        describe('when the model is not valid for any schema', function () {
+            describe('when the "promoted" schema is a better match than the "other" one', function () {
+                it('should select the "promoted" schema', function () {
+                    var localSchema = {
+                        title: 'Choose schema',
+                        oneOf: [
+                            {
+                                type: 'object',
+                                title: 'Option A',
+                                properties: {
+                                    a: { type: 'number' },
+                                    kind: { type: 'string', const: 'A' },
+                                },
+                                required: ['a'],
+                                promoted: true,
+                            },
+                            {
+                                type: 'object',
+                                title: 'Option B',
+                                properties: {
+                                    b: { type: 'number' },
+                                    kind: { type: 'string', const: 'B' },
+                                },
+                                required: ['b'],
+                            },
+                        ],
+                        promotion: {
+                            other: {
+                                title: 'Other title',
+                                icon: { name: 'bank', type: 'icon' },
+                                heading: { text: 'Other group heading', type: 'heading' },
+                            },
+                            default: 'other',
+                        },
+                        control: 'tab',
+                    };
+                    model = { kind: 'A' };
+                    props = __assign(__assign({}, props), { model: model, schema: localSchema });
+                    component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                    var control = component.find(PromotedOneOfControl);
+                    expect(control.props().selection).toBe('promoted');
+                });
+            });
+            describe('when the "other" schema is a better match than the "promoted" one', function () {
+                it('should select the "other" schema', function () {
+                    var localSchema = {
+                        title: 'Choose schema',
+                        oneOf: [
+                            {
+                                type: 'object',
+                                title: 'Option A',
+                                properties: {
+                                    a: { type: 'number' },
+                                    kind: { type: 'string', const: 'A' },
+                                },
+                                required: ['a'],
+                                promoted: true,
+                            },
+                            {
+                                type: 'object',
+                                title: 'Option B',
+                                properties: {
+                                    b: { type: 'number' },
+                                    kind: { type: 'string', const: 'B' },
+                                },
+                                required: ['b'],
+                            },
+                        ],
+                        promotion: {
+                            other: {
+                                title: 'Other title',
+                                icon: { name: 'bank', type: 'icon' },
+                                heading: { text: 'Other group heading', type: 'heading' },
+                            },
+                        },
+                        control: 'tab',
+                    };
+                    model = { kind: 'B' };
+                    props = __assign(__assign({}, props), { model: model, schema: localSchema });
+                    component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                    var control = component.find(PromotedOneOfControl);
+                    expect(control.props().selection).toBe('other');
+                });
+            });
+        });
+        describe('when the model is null', function () {
+            it('should select the default schema', function () {
+                var localSchema = {
+                    title: 'Choose schema',
+                    oneOf: [
+                        {
+                            type: 'object',
+                            title: 'Option A',
+                            properties: {
+                                a: { type: 'number' },
+                                kind: { type: 'string', const: 'A' },
+                            },
+                            required: ['a'],
+                            promoted: true,
+                        },
+                        {
+                            type: 'object',
+                            title: 'Option B',
+                            properties: {
+                                b: { type: 'number' },
+                                kind: { type: 'string', const: 'B' },
+                            },
+                            required: ['b'],
+                        },
+                    ],
+                    promotion: {
+                        other: {
+                            title: 'Other title',
+                            icon: { name: 'bank', type: 'icon' },
+                            heading: { text: 'Other group heading', type: 'heading' },
+                        },
+                        default: 'promoted',
+                    },
+                    control: 'tab',
+                };
+                model = null;
+                props = __assign(__assign({}, props), { model: model, schema: localSchema });
+                component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                var control = component.find(PromotedOneOfControl);
+                expect(control.props().selection).toBe('promoted');
+            });
+        });
+        it('should display the promoted option', function () {
+            var promoted = component.find(ObjectSchema);
+            expect(promoted).toHaveLength(1);
+        });
+        it('should display alert when present', function () {
+            expect(component.find(DynamicAlert)).toHaveLength(1);
+        });
+        it("should remove title, description and alert from the promoted option as it's already displayed", function () {
+            var promoted = component.find(ObjectSchema);
+            expect(promoted.props().schema).toMatchObject(__assign(__assign({}, schema.oneOf[0]), { title: undefined, description: undefined }));
+        });
+        // eslint-disable-next-line jest/expect-expect
+        it('should pass down all props to the promoted option', function () {
+            var promoted = component.find(ObjectSchema);
+            expectPropsToBeEqual(promoted, props);
+        });
+        describe('when the other option is selected', function () {
+            describe('when there is one other option', function () {
+                var objectSchema;
+                var initialize = function (promotionObject) {
+                    schema = {
+                        title: 'Choose schema',
+                        oneOf: __spreadArray([promotedSchema], oneOtherOption, true),
+                        promotion: promotionObject,
+                    };
+                    props = __assign(__assign({}, props), { schema: schema });
+                    component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                    getRadioGroup(component).simulate('change', 'other');
+                    objectSchema = component.find(GenericSchema).dive().find(ObjectSchema);
+                };
+                beforeEach(function () { return initialize(promotion); });
+                it('should render an object schema', function () {
+                    expect(objectSchema).toHaveLength(1);
+                });
+                it('should pass down the correct schema', function () {
+                    expect(objectSchema.props().schema).toMatchObject(__assign(__assign({}, schema.oneOf[1]), { title: 'Other group heading' }));
+                });
+                it('should accept empty heading', function () {
+                    var headinglessPromotion = __assign(__assign({}, promotion), { default: 'promoted', other: __assign(__assign({}, promotion.other), { heading: null }) });
+                    initialize(headinglessPromotion);
+                    expect(objectSchema.props().schema).toMatchObject(__assign(__assign({}, schema.oneOf[1]), { title: undefined }));
+                });
+                // eslint-disable-next-line jest/expect-expect
+                it('should pass down all props to the other option', function () {
+                    expectPropsToBeEqual(objectSchema, props);
+                });
+            });
+            describe('when there are more than one other option', function () {
+                var oneOfSchema;
+                beforeEach(function () {
+                    getRadioGroup(component).simulate('change', 'other');
+                    oneOfSchema = component.find(GenericSchema).dive().find(OneOfSchema);
+                });
+                it('should render an oneOf schema', function () {
+                    expect(oneOfSchema).toHaveLength(1);
+                });
+                it('should pass down the correct schema', function () {
+                    expect(oneOfSchema.props().schema).toMatchObject({
+                        title: 'Other group heading',
+                        control: 'tab',
+                        oneOf: twoOtherOptions,
+                    });
+                });
+                // eslint-disable-next-line jest/expect-expect
+                it('should pass down all props to the other option', function () {
+                    expectPropsToBeEqual(oneOfSchema, props);
+                });
+            });
+            describe('when promotion.displayTwice is true', function () {
+                var oneOfSchema;
+                beforeEach(function () {
+                    model = {};
+                    schema = {
+                        title: 'Choose schema',
+                        oneOf: __spreadArray([promotedSchema], twoOtherOptions, true),
+                        alert: {
+                            context: 'success',
+                            markdown: 'some alert',
+                            type: 'alert',
+                        },
+                        promotion: __assign(__assign({}, promotion), { displayTwice: true }),
+                        control: 'tab',
+                    };
+                    props = {
+                        schema: schema,
+                        model: model,
+                        errors: errors,
+                        onChange: onChange,
+                        submitted: submitted,
+                        onPersistAsync: onPersistAsync,
+                    };
+                    component = shallow(_jsx(PromotedOneOfSchema, __assign({}, props)));
+                    getRadioGroup(component).simulate('change', 'other');
+                    oneOfSchema = component.find(GenericSchema).dive().find(OneOfSchema);
+                });
+                it('should pass down all the oneOf options in the schema', function () {
+                    expect(oneOfSchema.props().schema.oneOf).toMatchObject(__spreadArray([
+                        promotedSchema
+                    ], twoOtherOptions, true));
+                });
+            });
+        });
+    });
+});
+var expectPropsToBeEqual = function (wrapper, props) {
+    expect(wrapper.props().model).toBe(props.model);
+    expect(wrapper.props().onChange).toBe(props.onChange);
+    expect(wrapper.props().submitted).toBe(props.submitted);
+    expect(wrapper.props().errors).toBe(props.errors);
+    expect(wrapper.props().onPersistAsync).toBe(props.onPersistAsync);
+};
+var getRadioGroup = function (component) {
+    return component
+        .find(PromotedOneOfControl)
+        .dive()
+        .find(PromotedOneOfRadioControl)
+        .dive()
+        .find(RadioGroup);
+};

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

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

package/build/legacy/jsonSchemaForm/promotedOneOfSchema/promoted-one-of-utils.js

@@ -0,0 +1,8 @@
+import { getBestMatchingSchemaIndexForValue } from '../oneOfSchema/utils';
+export var getSelectionFromModel = function (schema, model) {
+    var index = getBestMatchingSchemaIndexForValue(schema, model);
+    if (index !== null) {
+        return schema.oneOf[index].promoted ? 'promoted' : 'other';
+    }
+    return null;
+};

package/build/legacy/jsonSchemaForm/promotedOneOfSchema/promotedOneOfControl/PromotedOneOfCheckboxControl.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Checkbox } from '@transferwise/components';
+var PromotedOneOfCheckboxControl = function (props) {
+    var id = props.id, selection = props.selection, setSelection = props.setSelection;
+    var _a = props.promotion, promoted = _a.promoted, other = _a.other, checkedMeans = _a.checkedMeans;
+    var title = checkedMeans === 'other' ? other.title : (promoted === null || promoted === void 0 ? void 0 : promoted.title) || props.promotedOneOf.title;
+    var selectionWhenChecked = checkedMeans === 'other' ? 'other' : 'promoted';
+    var selectionWhenUnchecked = checkedMeans === 'other' ? 'promoted' : 'other';
+    var checked = selection === selectionWhenChecked;
+    var toggleSelection = function () {
+        setSelection(checked ? selectionWhenUnchecked : selectionWhenChecked);
+    };
+    return (_jsx("div", { className: "form-group", children: _jsx(Checkbox, { id: id, label: title, checked: checked, onChange: toggleSelection }) }));
+};
+PromotedOneOfCheckboxControl.defaultProps = {};
+export default PromotedOneOfCheckboxControl;

package/build/legacy/jsonSchemaForm/promotedOneOfSchema/promotedOneOfControl/PromotedOneOfCheckboxControl.spec.js

@@ -0,0 +1,125 @@
+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 { Checkbox } from '@transferwise/components';
+import { shallow, mount } from 'enzyme';
+import PromotedOneOfCheckboxControl from './PromotedOneOfCheckboxControl';
+describe('Given a PromotedOneOfCheckboxControl component', function () {
+    var component;
+    var props;
+    var setSelection;
+    var selection = 'promoted';
+    var promotedOneOf = {
+        title: 'a promoted oneOf title',
+        description: 'a promoted oneOf description',
+    };
+    var promotion = {
+        control: 'checkbox',
+        promoted: {
+            title: 'Promoted title',
+        },
+        other: {
+            title: 'Other title',
+        },
+    };
+    var promotionMeansOther = __assign(__assign({}, promotion), { checkedMeans: 'other' });
+    beforeEach(function () {
+        setSelection = jest.fn();
+        props = {
+            promotedOneOf: promotedOneOf,
+            promotion: promotion,
+            selection: selection,
+            setSelection: setSelection,
+        };
+    });
+    describe('when given a radio control', function () {
+        it('should render checkbox', function () {
+            component = shallow(_jsx(PromotedOneOfCheckboxControl, __assign({}, props)));
+            expect(component.find(Checkbox)).toHaveLength(1);
+        });
+    });
+    describe('when checked means other', function () {
+        beforeEach(function () {
+            component = mount(_jsx(PromotedOneOfCheckboxControl, __assign({}, props, { promotion: promotionMeansOther, selection: "promoted" })));
+        });
+        it('should use the other title for the checkbox', function () {
+            expect(component.find(Checkbox).props().label).toBe('Other title');
+        });
+        describe('when promoted is selected initially', function () {
+            it('should be unchecked', function () {
+                expect(component.find(Checkbox).props().checked).toBe(false);
+            });
+            describe('when the box is checked', function () {
+                it('should trigger selection change to other', function () {
+                    component.find(Checkbox).find('input').simulate('change', true);
+                    expect(setSelection).toHaveBeenCalledWith('other');
+                });
+            });
+        });
+        describe('when other is selected initially', function () {
+            beforeEach(function () {
+                component = mount(_jsx(PromotedOneOfCheckboxControl, __assign({}, props, { promotion: promotionMeansOther, selection: "other" })));
+            });
+            it('should be checked', function () {
+                expect(component.find(Checkbox).props().checked).toBe(true);
+            });
+            describe('when the box is unchecked', function () {
+                it('should trigger selection change to promoted', function () {
+                    component.find(Checkbox).find('input').simulate('change', false);
+                    expect(setSelection).toHaveBeenCalledWith('promoted');
+                });
+            });
+        });
+    });
+    describe('when checked means promoted', function () {
+        beforeEach(function () {
+            component = shallow(_jsx(PromotedOneOfCheckboxControl, __assign({}, props)));
+        });
+        it('should use the promoted title', function () {
+            expect(component.find(Checkbox).props().label).toBe('Promoted title');
+        });
+        describe('when the promoted title is missing', function () {
+            it('should use the promoted oneOf title', function () {
+                component = shallow(_jsx(PromotedOneOfCheckboxControl, __assign({}, props, { promotion: {} })));
+                expect(component.find(Checkbox).props().label).toBe('a promoted oneOf title');
+            });
+        });
+        describe('when other is selected initially', function () {
+            beforeEach(function () {
+                component = mount(_jsx(PromotedOneOfCheckboxControl, __assign({}, props, { selection: "other" })));
+            });
+            it('should be unchecked by default', function () {
+                expect(component.find(Checkbox).props().checked).toBe(false);
+            });
+            describe('when the box is checked', function () {
+                it('should trigger selection change to promoted', function () {
+                    component.find(Checkbox).find('input').simulate('change', true);
+                    expect(setSelection).toHaveBeenCalledWith('promoted');
+                });
+            });
+        });
+        describe('when promoted is selected initially', function () {
+            beforeEach(function () {
+                component = mount(_jsx(PromotedOneOfCheckboxControl, __assign({}, props, { selection: "promoted" })));
+            });
+            it('should be checked by default', function () {
+                expect(component.find(Checkbox).props().checked).toBe(true);
+            });
+            describe('when the box is unchecked', function () {
+                it('should trigger selection change to other', function () {
+                    component.find(Checkbox).find('input').simulate('change', false);
+                    expect(setSelection).toHaveBeenCalledWith('other');
+                });
+            });
+        });
+    });
+});

package/build/legacy/jsonSchemaForm/promotedOneOfSchema/promotedOneOfControl/PromotedOneOfControl.js

@@ -0,0 +1,31 @@
+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 { generateRandomId } from '../../../common/utils';
+import PromotedOneOfCheckboxControl from './PromotedOneOfCheckboxControl';
+import PromotedOneOfRadioControl from './PromotedOneOfRadioControl';
+function PromotedOneOfControl(props) {
+    var controlType = props.promotion.control || 'radio';
+    switch (controlType) {
+        case 'radio':
+            return _jsx(PromotedOneOfRadioControl, __assign({}, props));
+        case 'checkbox':
+            return _jsx(PromotedOneOfCheckboxControl, __assign({}, props));
+        default:
+            return _jsx(_Fragment, {});
+    }
+}
+PromotedOneOfControl.defaultProps = {
+    id: generateRandomId(),
+    title: undefined,
+};
+export default PromotedOneOfControl;