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

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

@@ -1,420 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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;