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

package/build/legacy/jsonSchemaForm/genericSchema/GenericSchema.spec.js

@@ -1,334 +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 { shallow } from 'enzyme';
-import * as loggingModule from '../../common/contexts/logContext/LogContext';
-import { mockUseLogger } from '../../test-utils';
-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 ReadOnlySchema from '../readOnlySchema';
-import GenericSchema from '.';
-jest.spyOn(loggingModule, 'useLogger').mockImplementation(mockUseLogger);
-describe('Given a component for rendering any generic schema', function () {
-    var component;
-    var props;
-    var sharedProps;
-    var onChange;
-    var schema;
-    var model;
-    var errors;
-    var onPersistAsync;
-    var required = true;
-    var submitted = false;
-    beforeEach(function () {
-        onChange = jest.fn();
-        onPersistAsync = jest.fn();
-        sharedProps = {
-            required: required,
-            onChange: onChange,
-            submitted: submitted,
-            onPersistAsync: onPersistAsync,
-        };
-    });
-    describe('when a string schema is supplied', function () {
-        var stringSchemaComponent;
-        beforeEach(function () {
-            model = 'foo';
-            schema = {
-                type: 'string',
-            };
-            errors = 'bar';
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            stringSchemaComponent = component.find(BasicTypeSchema);
-        });
-        it('should render a StringSchema', function () {
-            expect(stringSchemaComponent).toHaveLength(1);
-        });
-        it('should pass through the supplied data to the StringSchema', function () {
-            expect(stringSchemaComponent.prop('schema')).toStrictEqual(schema);
-            expect(stringSchemaComponent.prop('model')).toStrictEqual(model);
-            expect(stringSchemaComponent.prop('errors')).toStrictEqual(errors);
-        });
-        describe('when the child component triggers onChange', function () {
-            beforeEach(function () {
-                stringSchemaComponent.simulate('change', 'bar', schema);
-            });
-            it('should trigger the components onChange with the model', function () {
-                expect(onChange).toHaveBeenCalledWith('bar', schema);
-            });
-        });
-    });
-    describe('when a number schema is supplied', function () {
-        var numberSchemaComponent;
-        beforeEach(function () {
-            model = 1;
-            schema = {
-                type: 'number',
-            };
-            errors = 'bar';
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            numberSchemaComponent = component.find(BasicTypeSchema);
-        });
-        it('should render a StringSchema', function () {
-            expect(numberSchemaComponent).toHaveLength(1);
-        });
-        it('should pass through the supplied data to the StringSchema', function () {
-            expect(numberSchemaComponent.prop('schema')).toStrictEqual(schema);
-            expect(numberSchemaComponent.prop('model')).toStrictEqual(model);
-            expect(numberSchemaComponent.prop('errors')).toStrictEqual(errors);
-        });
-        describe('when the child component triggers onChange', function () {
-            beforeEach(function () {
-                numberSchemaComponent.simulate('change', 2, schema);
-            });
-            it('should trigger the components onChange with the model', function () {
-                expect(onChange).toHaveBeenCalledWith(2, schema);
-            });
-        });
-    });
-    describe('when a boolean schema is supplied', function () {
-        var booleanSchemaComponent;
-        beforeEach(function () {
-            model = true;
-            schema = {
-                type: 'boolean',
-            };
-            errors = 'bar';
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            booleanSchemaComponent = component.find(BasicTypeSchema);
-        });
-        it('should render a StringSchema', function () {
-            expect(booleanSchemaComponent).toHaveLength(1);
-        });
-        it('should pass through the supplied data to the StringSchema', function () {
-            expect(booleanSchemaComponent.prop('schema')).toStrictEqual(schema);
-            expect(booleanSchemaComponent.prop('model')).toStrictEqual(model);
-            expect(booleanSchemaComponent.prop('errors')).toStrictEqual(errors);
-        });
-        describe('when the child component triggers onChange', function () {
-            beforeEach(function () {
-                booleanSchemaComponent.simulate('change', false, schema);
-            });
-            it('should trigger the components onChange with the model', function () {
-                expect(onChange).toHaveBeenCalledWith(false, schema);
-            });
-        });
-    });
-    describe('when an object schema is supplied', function () {
-        var objectSchemaComponent;
-        beforeEach(function () {
-            model = { foo: 'bar' };
-            schema = {
-                type: 'object',
-                properties: {
-                    foo: {
-                        type: 'string',
-                    },
-                },
-            };
-            errors = { foo: 'barbar' };
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            objectSchemaComponent = component.find(ObjectSchema);
-        });
-        it('should render a ObjectSchema', function () {
-            expect(objectSchemaComponent).toHaveLength(1);
-        });
-        it('should pass through the supplied data to the ObjectSchema', function () {
-            expect(objectSchemaComponent.prop('schema')).toStrictEqual(schema);
-            expect(objectSchemaComponent.prop('model')).toStrictEqual(model);
-            expect(objectSchemaComponent.prop('errors')).toStrictEqual(errors);
-        });
-        describe('when the child component triggers onChange', function () {
-            beforeEach(function () {
-                objectSchemaComponent.simulate('change', { foo: 'barbar' }, schema.properties.foo);
-            });
-            it('should trigger the components onChange with the model', function () {
-                expect(onChange).toHaveBeenCalledWith({ foo: 'barbar' }, schema.properties.foo);
-            });
-        });
-    });
-    describe('when a oneOf schema is supplied', function () {
-        var oneOfComponent;
-        beforeEach(function () {
-            model = 'a';
-            schema = {
-                oneOf: [
-                    {
-                        type: 'string',
-                    },
-                ],
-            };
-            errors = 'foo';
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            oneOfComponent = component.find(OneOfSchema);
-        });
-        it('should render a oneOfSchema', function () {
-            expect(oneOfComponent).toHaveLength(1);
-        });
-        it('should pass through the supplied data to the oneOfSchema', function () {
-            expect(oneOfComponent.prop('schema')).toStrictEqual(schema);
-            expect(oneOfComponent.prop('model')).toStrictEqual(model);
-            expect(oneOfComponent.prop('errors')).toStrictEqual(errors);
-        });
-        describe('when the child component triggers onChange', function () {
-            beforeEach(function () {
-                oneOfComponent.simulate('change', 'b', schema.oneOf[0]);
-            });
-            it('should trigger the components onChange with the model', function () {
-                expect(onChange).toHaveBeenCalledWith('b', schema.oneOf[0]);
-            });
-        });
-    });
-    describe('when a oneOf schema also has a type', function () {
-        var oneOfComponent;
-        var basicTypeSchemaComponent;
-        beforeEach(function () {
-            model = 'a';
-            schema = {
-                type: 'string',
-                oneOf: [
-                    {
-                        const: 'a',
-                    },
-                ],
-            };
-            errors = 'foo';
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            oneOfComponent = component.find(OneOfSchema);
-            basicTypeSchemaComponent = component.find(BasicTypeSchema);
-        });
-        it('should render a oneOfSchema', function () {
-            expect(oneOfComponent).toHaveLength(1);
-        });
-        it('should not render a basicTypeSchema', function () {
-            expect(basicTypeSchemaComponent).toHaveLength(0);
-        });
-    });
-    describe('when an allOf schema is supplied', function () {
-        var allOfComponent;
-        beforeEach(function () {
-            model = 'a';
-            schema = {
-                allOf: [
-                    {
-                        type: 'string',
-                    },
-                ],
-            };
-            errors = 'foo';
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            allOfComponent = component.find(AllOfSchema);
-        });
-        it('should render a AllOfSchema', function () {
-            expect(allOfComponent).toHaveLength(1);
-        });
-        it('should pass through the supplied data to the AllOfSchema', function () {
-            expect(allOfComponent.prop('schema')).toStrictEqual(schema);
-            expect(allOfComponent.prop('model')).toStrictEqual(model);
-            expect(allOfComponent.prop('errors')).toStrictEqual(errors);
-        });
-        describe('when the child component triggers onChange', function () {
-            beforeEach(function () {
-                allOfComponent.simulate('change', 'b', schema.allOf[0]);
-            });
-            it('should trigger the components onChange with the model', function () {
-                expect(onChange).toHaveBeenCalledWith('b', schema.allOf[0]);
-            });
-        });
-    });
-    describe('when a persist async schema is supplied', function () {
-        beforeEach(function () {
-            model = null;
-            schema = {
-                type: 'string',
-                title: 'Text input',
-                persistAsync: {
-                    method: 'POST',
-                    url: '/v1/cards',
-                    param: 'cardNumber',
-                    idProperty: 'cardToken',
-                    schema: {
-                        title: 'Persist Async Title',
-                        type: 'string',
-                        placeholder: 'aPlaceholder',
-                    },
-                },
-            };
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-        });
-        it('should render persist async schema', function () {
-            expect(component.find(PersistAsyncSchema)).toHaveLength(1);
-        });
-        it('should pass through the supplied data to the PersistAsyncSchema', function () {
-            var persistAsyncComponent = component.find(PersistAsyncSchema);
-            expect(persistAsyncComponent.prop('schema')).toStrictEqual(schema);
-            expect(persistAsyncComponent.prop('model')).toStrictEqual(model);
-            expect(persistAsyncComponent.prop('errors')).toStrictEqual(errors);
-        });
-        it('should not render basic type schema', function () {
-            expect(component.find(BasicTypeSchema)).toHaveLength(0);
-        });
-    });
-    describe('when supplied schema is readOnly', function () {
-        describe('when supplied schema is basic (string, number, boolean)', function () {
-            it('renders a ReadOnlySchema', function () {
-                var shallowWrapper = shallow(_jsx(GenericSchema, __assign({}, sharedProps, { model: null, schema: { type: 'string', readOnly: true } })));
-                expect(shallowWrapper.find(ReadOnlySchema)).toHaveLength(1);
-            });
-        });
-        describe('when supplied schema is allOf', function () {
-            it('renders an AllOfSchema, ignoring the "readOnly" property', function () {
-                var shallowWrapper = shallow(_jsx(GenericSchema, __assign({}, sharedProps, { model: null, schema: { readOnly: true, allOf: [{ type: 'string' }, { type: 'number' }] } })));
-                expect(shallowWrapper.find(AllOfSchema)).toHaveLength(1);
-                expect(shallowWrapper.find(ReadOnlySchema)).toHaveLength(0);
-            });
-        });
-    });
-    describe('when array schema is supplied', function () {
-        var arraySchemaComponent;
-        beforeEach(function () {
-            model = null;
-            schema = {
-                type: 'array',
-            };
-            errors = 'bar';
-            props = __assign(__assign({}, sharedProps), { model: model, schema: schema, errors: errors });
-            component = shallow(_jsx(GenericSchema, __assign({}, props)));
-            arraySchemaComponent = component.find(ArraySchema);
-        });
-        it('should render the array schema', function () {
-            expect(arraySchemaComponent).toHaveLength(1);
-        });
-        it('should pass through all the supplied props', function () {
-            expect(arraySchemaComponent.prop('schema')).toStrictEqual(schema);
-            expect(arraySchemaComponent.prop('model')).toStrictEqual(model);
-            expect(arraySchemaComponent.prop('errors')).toStrictEqual(errors);
-        });
-        it('should trigger onChange with what the component passes through', function () {
-            var params = ['randomFileId', 123, 'stringValue'];
-            arraySchemaComponent.simulate('change', params, schema);
-            expect(onChange).toHaveBeenCalledWith(params, schema);
-        });
-    });
-});

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

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

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

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

package/build/legacy/jsonSchemaForm/help/Help.spec.js

@@ -1,61 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Info } from '@transferwise/components';
-import { mount, wait } from '../../test-utils';
-import Help from './Help';
-describe('Given a Help component renders from a help schema', function () {
-    var help = {
-        markdown: 'some markdown',
-    };
-    var component;
-    beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    component = mount(_jsx(Help, { help: help }));
-                    return [4 /*yield*/, wait(0)];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should render an info component', function () {
-        expect(component.find(Info)).toHaveLength(1);
-    });
-});

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

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

package/build/legacy/jsonSchemaForm/index.js

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

package/build/legacy/jsonSchemaForm/objectSchema/ObjectSchema.js

@@ -1,77 +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, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { Header } from '@transferwise/components';
-import classNames from 'classnames';
-import { useState, useEffect } from 'react';
-import { isEqual } from '../../common/utils';
-import { getValidObjectModelParts } from '../../common/validators';
-import { DynamicAlert } from '../../layout';
-import GenericSchema from '../genericSchema';
-var getSchemaColumnClasses = function (width) { return ({
-    'col-xs-12': true,
-    'col-sm-6': width === 'md',
-    'col-sm-4': width === 'sm',
-}); };
-function ObjectSchema(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
-            model[propertyName] = onChangeProps.model;
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-            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(_Fragment, { children: [props.schema.alert && _jsx(DynamicAlert, { component: props.schema.alert }), _jsxs("fieldset", { children: [props.schema.title && !props.hideTitle && (_jsx(Header, { title: props.schema.title, as: "legend" })), props.schema.description && !props.hideTitle && _jsxs("p", { children: [" ", props.schema.description, " "] }), _jsx("div", { className: "row", children: orderedPropertyNames.map(function (propertyName) { return (_jsx("div", { className: classNames(getSchemaColumnClasses(props.schema.properties[propertyName].width)), children: _jsx(GenericSchema, { schema: props.schema.properties[propertyName], model: props.model && props.model[propertyName], errors: propsErrors === null || propsErrors === void 0 ? void 0 : 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/legacy/jsonSchemaForm/objectSchema/index.js

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

package/build/legacy/jsonSchemaForm/oneOfSchema/OneOfSchema.js

@@ -1,155 +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, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { Header } from '@transferwise/components';
-import classNames from 'classnames';
-import { useEffect, useMemo, useState } from 'react';
-import { useEventDispatcher } from '../../common/contexts';
-import { useDebouncedFunction } from '../../common/hooks';
-import { generateRandomId, isConstSchema, isNoNConstSchema } from '../../common/utils';
-import { getValidModelParts, getValidationFailures, isArray, isEmpty, } from '../../common/validators';
-import { DynamicAlert } from '../../layout';
-import ControlFeedback from '../controlFeedback';
-import GenericSchema from '../genericSchema';
-import Help from '../help';
-import SchemaFormControl from '../schemaFormControl';
-import { getActiveSchemaIndex, getValidIndexFromValue } from './utils';
-function OneOfSchema(props) {
-    var onEvent = useEventDispatcher();
-    var _a = useState(false), changed = _a[0], setChanged = _a[1];
-    var _b = useState(false), focused = _b[0], setFocused = _b[1];
-    var _c = useState(false), blurred = _c[0], setBlurred = _c[1];
-    var id = useMemo(function () { return props.schema.$id || generateRandomId(); }, [props.schema.$id]);
-    var _d = useState(getActiveSchemaIndex(props.schema, props.model)), schemaIndex = _d[0], setSchemaIndex = _d[1];
-    var _e = useState(getModelPartsForSchemas(props.model, props.schema.oneOf)), models = _e[0], setModels = _e[1];
-    var debouncedTrackEvent = useDebouncedFunction(onEvent, 200);
-    var onSearchChange = function (searchValue) {
-        debouncedTrackEvent('Dynamic Flow - OneOf Searched', {
-            oneOfId: props.schema.analyticsId,
-            searchValueLength: searchValue.length,
-        });
-    };
-    // When the schema we receive from parent changes
-    useEffect(function () {
-        var modelIndex = getValidIndexFromValue(props.schema, props.model);
-        var defaultIndex = getValidIndexFromValue(props.schema, props.schema.default);
-        if (modelIndex === -1 && defaultIndex >= 0) {
-            onChooseNewSchema(defaultIndex, 'init');
-        }
-    }, [props.schema]);
-    if (!isArray(props.schema.oneOf)) {
-        // eslint-disable-next-line no-console
-        console.error('Incorrect format', props.schema);
-        return null;
-    }
-    var onChildModelChange = function (index, onChangeParameters) {
-        setModels(__spreadArray(__spreadArray(__spreadArray([], models.slice(0, index), true), [onChangeParameters.model], false), models.slice(index + 1), true));
-        setChanged(true);
-        props.onChange(onChangeParameters);
-    };
-    var onFocus = function () {
-        setFocused(true);
-    };
-    var onBlur = function () {
-        setFocused(false);
-        setBlurred(true);
-    };
-    // TODO: LOW avoid type assertion
-    var onChooseNewSchema = function (index, type, metadata) {
-        setSchemaIndex(index);
-        var newSchema = props.schema.oneOf[index];
-        if (isConstSchema(newSchema)) {
-            // If new schema is a const we want to share the parent schema, not the const
-            var model = newSchema.const;
-            props.onChange({
-                model: model,
-                triggerSchema: props.schema,
-                triggerModel: model,
-                type: type,
-                metadata: metadata,
-            });
-        }
-        else {
-            props.onChange({
-                model: models[index],
-                triggerSchema: newSchema,
-                triggerModel: models[index],
-                type: type,
-                metadata: metadata,
-            });
-        }
-        if (type !== 'init' && props.schema.analyticsId) {
-            onEvent('Dynamic Flow - OneOf Selected', {
-                oneOfId: props.schema.analyticsId,
-                schemaId: newSchema === null || newSchema === void 0 ? void 0 : newSchema.analyticsId,
-            });
-        }
-    };
-    var schemaForSelect = mapSchemasForSelect(props.schema);
-    var validations = getValidations(props, schemaIndex);
-    var formGroupClasses = {
-        'form-group': true,
-        'has-error': (!changed && props.errors && !isEmpty(props.errors)) ||
-            ((props.submitted || (changed && blurred)) && validations.length),
-    };
-    var feedbackId = "".concat(id, "-feedback");
-    return (_jsxs(_Fragment, { children: [(props.schema.oneOf.length > 1 || isConstSchema(props.schema.oneOf[0])) && (_jsxs(_Fragment, { children: [props.schema.alert && _jsx(DynamicAlert, { component: props.schema.alert }), _jsxs("div", { className: classNames(formGroupClasses), children: [getTitleAndHelp(props.schema, id), _jsx(SchemaFormControl, { id: id, schema: schemaForSelect, value: schemaIndex, disabled: props.disabled, describedBy: feedbackId, required: props.required, onChange: onChooseNewSchema, onFocus: onFocus, onBlur: onBlur, onSearchChange: onSearchChange }), _jsx(ControlFeedback, { id: feedbackId, changed: changed, focused: focused, blurred: blurred, submitted: props.submitted, errors: errorsToString(props.errors), schema: props.schema, validations: validations, infoMessage: null })] })] })), isNoNConstSchema(props.schema.oneOf[schemaIndex]) && (_jsx(GenericSchema, { schema: props.schema.oneOf[schemaIndex], model: models[schemaIndex], errors: props.errors, submitted: props.submitted, hideTitle: true, disabled: props.disabled, onChange: function (parameters) { return onChildModelChange(schemaIndex, parameters); }, onPersistAsync: props.onPersistAsync }))] }));
-}
-function getTitleAndHelp(schema, forId) {
-    var _a;
-    var helpElement = schema.help ? _jsx(Help, { help: schema.help }) : null;
-    var titleElement = isConstSchema(schema.oneOf[0]) ? (_jsx("div", { className: "m-b-1", children: _jsxs("label", { className: "control-label d-inline", htmlFor: forId, children: [schema.title, " ", helpElement] }) })) : (_jsx(_Fragment, { children: helpElement ? (_jsxs("h4", { className: "m-b-2", children: [schema.title, " ", helpElement] })) : (_jsx(Header, { title: (_a = schema.title) !== null && _a !== void 0 ? _a : '' })) }));
-    return schema.title ? titleElement : helpElement;
-}
-function getValidations(props, schemaIndex) {
-    var selectedSchema = props.schema.oneOf[schemaIndex !== null && schemaIndex !== void 0 ? schemaIndex : -1];
-    if (isConstSchema(selectedSchema)) {
-        return getValidationFailures(selectedSchema.const, props.schema, Boolean(props.required));
-    }
-    if (schemaIndex === null || schemaIndex < 0) {
-        return getValidationFailures(null, props.schema, Boolean(props.required));
-    }
-    return [];
-}
-function errorsToString(errors) {
-    // When oneOf represents a select, errors should be of type string
-    if (typeof errors === 'string') {
-        return errors;
-    }
-    return null;
-}
-function getModelPartsForSchemas(model, schemas) {
-    return schemas.map(function (schema) { return getValidModelParts(model, schema); });
-}
-// We want our model to be the index, so alter the oneOf schemas to be a const
-function mapSchemasForSelect(schema) {
-    return __assign(__assign({}, schema), { oneOf: schema.oneOf.map(mapOneOfToConst) });
-}
-function mapOneOfToConst(schema, index) {
-    var title = schema.title, description = schema.description, _a = schema.disabled, disabled = _a === void 0 ? false : _a, icon = schema.icon, image = schema.image, keywords = schema.keywords;
-    // TODO LOW avoid type assertion below -- consider adding { type: 'integer' }
-    return { title: title, description: description, disabled: disabled, icon: icon, image: image, const: index, keywords: keywords };
-}
-OneOfSchema.defaultProps = {
-    required: false,
-    disabled: false,
-};
-export default OneOfSchema;

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

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